/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.3.0
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */
#ifndef SWIG_inworld_WRAP_H_
#define SWIG_inworld_WRAP_H_


#ifndef SWIGIMPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGDLLIMPORT
#   else
#     define SWIGDLLIMPORT __declspec(dllimport)
#   endif
# else
#   define SWIGDLLIMPORT
# endif
# define SWIGIMPORT extern SWIGDLLIMPORT
#endif

#include <stddef.h>


typedef struct SwigObj SwigObj;

#include <stdbool.h>
typedef struct SwigObj_inworld_Status inworld_Status;

typedef struct SwigObj_inworld_StatusOr_opaque inworld_StatusOr_opaque;

typedef struct SwigObj_inworld_StatusOr_int inworld_StatusOr_int;

typedef struct SwigObj_inworld_StatusOr_string inworld_StatusOr_string;

typedef struct SwigObj_inworld_StatusOr_vector_string inworld_StatusOr_vector_string;

typedef struct SwigObj_inworld_StatusOr_vector_float inworld_StatusOr_vector_float;

typedef struct SwigObj_inworld_StatusOr_vector_vector_float inworld_StatusOr_vector_vector_float;

typedef struct SwigObj_inworld_StatusOr_AudioChunk inworld_StatusOr_AudioChunk;

typedef struct SwigObj_inworld_StatusOr_Content inworld_StatusOr_Content;

typedef struct SwigObj_inworld_StatusOr_KnowledgeCollection inworld_StatusOr_KnowledgeCollection;

typedef struct SwigObj_inworld_StatusOr_MemorySnapshot inworld_StatusOr_MemorySnapshot;

typedef struct SwigObj_inworld_StatusOr_CheckSafetyResponse inworld_StatusOr_CheckSafetyResponse;

typedef struct SwigObj_inworld_StatusOr_SilenceIntervals inworld_StatusOr_SilenceIntervals;

typedef struct SwigObj_inworld_StatusOr_vector_CompiledIntent inworld_StatusOr_vector_CompiledIntent;

typedef struct SwigObj_inworld_StatusOr_vector_IntentMatch inworld_StatusOr_vector_IntentMatch;

typedef struct SwigObj_inworld_StatusOr_vector_EntityMatch inworld_StatusOr_vector_EntityMatch;

typedef struct SwigObj_inworld_StatusOr_vector_PhraseMatch inworld_StatusOr_vector_PhraseMatch;

typedef struct SwigObj_inworld_StatusOr_LLMInterface inworld_StatusOr_LLMInterface;

typedef struct SwigObj_inworld_StatusOr_LLMRouting inworld_StatusOr_LLMRouting;

typedef struct SwigObj_inworld_StatusOr_STTInterface inworld_StatusOr_STTInterface;

typedef struct SwigObj_inworld_StatusOr_StreamingSTTInterface inworld_StatusOr_StreamingSTTInterface;

typedef struct SwigObj_inworld_StatusOr_TTSInterface inworld_StatusOr_TTSInterface;

typedef struct SwigObj_inworld_StatusOr_VADInterface inworld_StatusOr_VADInterface;

typedef struct SwigObj_inworld_StatusOr_AECFilterInterface inworld_StatusOr_AECFilterInterface;

typedef struct SwigObj_inworld_StatusOr_IntentCompilerInterface inworld_StatusOr_IntentCompilerInterface;

typedef struct SwigObj_inworld_StatusOr_IntentMatcherInterface inworld_StatusOr_IntentMatcherInterface;

typedef struct SwigObj_inworld_StatusOr_KeywordMatcherInterface inworld_StatusOr_KeywordMatcherInterface;

typedef struct SwigObj_inworld_StatusOr_KeywordMatcherResponse inworld_StatusOr_KeywordMatcherResponse;

typedef struct SwigObj_inworld_StatusOr_KnowledgeInterface inworld_StatusOr_KnowledgeInterface;

typedef struct SwigObj_inworld_StatusOr_KnowledgeRetrieverInterface inworld_StatusOr_KnowledgeRetrieverInterface;

typedef struct SwigObj_inworld_StatusOr_MemoryInterface inworld_StatusOr_MemoryInterface;

typedef struct SwigObj_inworld_StatusOr_SafetyCheckerInterface inworld_StatusOr_SafetyCheckerInterface;

typedef struct SwigObj_inworld_StatusOr_TextEmbedderInterface inworld_StatusOr_TextEmbedderInterface;

typedef struct SwigObj_inworld_StatusOr_EmojiRemover inworld_StatusOr_EmojiRemover;

typedef struct SwigObj_inworld_StatusOr_SentenceStream inworld_StatusOr_SentenceStream;

typedef struct SwigObj_inworld_StatusOr_SubstringRemover inworld_StatusOr_SubstringRemover;

typedef struct SwigObj_inworld_StatusOr_TextInBracketsRemover inworld_StatusOr_TextInBracketsRemover;

typedef struct SwigObj_inworld_StatusOr_ContentToStringStream inworld_StatusOr_ContentToStringStream;

typedef struct SwigObj_inworld_StatusOr_NERInterface inworld_StatusOr_NERInterface;

typedef struct SwigObj_inworld_StatusOr_CreationContext inworld_StatusOr_CreationContext;

typedef struct SwigObj_inworld_StatusOr_MCPClientInterface inworld_StatusOr_MCPClientInterface;

typedef struct SwigObj_inworld_ComponentStore inworld_ComponentStore;

typedef struct SwigObj_inworld_CreationContext inworld_CreationContext;

typedef struct SwigObj_inworld_ComponentRegistry inworld_ComponentRegistry;

enum inworld_StatusCode {
  inworld_StatusCode_kOk = 0,
  inworld_StatusCode_kCancelled = 1,
  inworld_StatusCode_kUnknown = 2,
  inworld_StatusCode_kInvalidArgument = 3,
  inworld_StatusCode_kDeadlineExceeded = 4,
  inworld_StatusCode_kNotFound = 5,
  inworld_StatusCode_kAlreadyExists = 6,
  inworld_StatusCode_kPermissionDenied = 7,
  inworld_StatusCode_kResourceExhausted = 8,
  inworld_StatusCode_kFailedPrecondition = 9,
  inworld_StatusCode_kAborted = 10,
  inworld_StatusCode_kOutOfRange = 11,
  inworld_StatusCode_kUnimplemented = 12,
  inworld_StatusCode_kInternal = 13,
  inworld_StatusCode_kUnavailable = 14,
  inworld_StatusCode_kDataLoss = 15,
  inworld_StatusCode_kUnauthenticated = 16,
  inworld_StatusCode_kDoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_ = 20
};

typedef struct SwigObj_inworld_vector_StatusCode inworld_vector_StatusCode;

typedef struct SwigObj_inworld_NodeExecutionConfig inworld_NodeExecutionConfig;

typedef struct SwigObj_inworld_StatusOr_CustomConfigWrapper inworld_StatusOr_CustomConfigWrapper;

typedef struct SwigObj_inworld_StatusOr_CustomExecutionConfigWrapper inworld_StatusOr_CustomExecutionConfigWrapper;

typedef struct SwigObj_inworld_vector_CustomConfigWrapper inworld_vector_CustomConfigWrapper;

typedef struct SwigObj_inworld_vector_CustomExecutionConfigWrapper inworld_vector_CustomExecutionConfigWrapper;

typedef struct SwigObj_inworld_SerializerRegistry inworld_SerializerRegistry;

typedef struct SwigObj_inworld_ConfigWrapperDestructor inworld_ConfigWrapperDestructor;

typedef struct SwigObj_inworld_CustomConfigWrapper inworld_CustomConfigWrapper;

typedef struct SwigObj_inworld_CustomExecutionConfigWrapper inworld_CustomExecutionConfigWrapper;

typedef struct SwigObj_inworld_CustomConfigThreadedSerializeExecutor inworld_CustomConfigThreadedSerializeExecutor;

typedef struct SwigObj_inworld_CustomConfigThreadedDeserializeExecutor inworld_CustomConfigThreadedDeserializeExecutor;

typedef struct SwigObj_inworld_CustomExecutionConfigThreadedSerializeExecutor inworld_CustomExecutionConfigThreadedSerializeExecutor;

typedef struct SwigObj_inworld_CustomExecutionConfigThreadedDeserializeExecutor inworld_CustomExecutionConfigThreadedDeserializeExecutor;

typedef struct SwigObj_inworld_InputStream_TTSOutput inworld_InputStream_TTSOutput;

typedef struct SwigObj_inworld_InputStream_Content inworld_InputStream_Content;

typedef struct SwigObj_inworld_InputStream_string inworld_InputStream_string;

typedef struct SwigObj_inworld_InputStream_AudioChunk inworld_InputStream_AudioChunk;

typedef struct SwigObj_inworld_InputStream_BaseData inworld_InputStream_BaseData;

typedef struct SwigObj_inworld_StatusOr_InputStream_string inworld_StatusOr_InputStream_string;

typedef struct SwigObj_inworld_StatusOr_InputStream_AudioChunk inworld_StatusOr_InputStream_AudioChunk;

typedef struct SwigObj_inworld_StatusOr_InputStream_Content inworld_StatusOr_InputStream_Content;

typedef struct SwigObj_inworld_StatusOr_InputStream_BaseData inworld_StatusOr_InputStream_BaseData;

typedef struct SwigObj_inworld_StatusOr_InputStream_TTSOutput inworld_StatusOr_InputStream_TTSOutput;

typedef struct SwigObj_inworld_BlockingStream_TTSOutput inworld_BlockingStream_TTSOutput;

typedef struct SwigObj_inworld_BlockingStream_Content inworld_BlockingStream_Content;

typedef struct SwigObj_inworld_BlockingStream_AudioChunk inworld_BlockingStream_AudioChunk;

typedef struct SwigObj_inworld_BlockingStream_string inworld_BlockingStream_string;

typedef struct SwigObj_inworld_BlockingStream_BaseData inworld_BlockingStream_BaseData;

typedef struct SwigObj_inworld_StatusOr_CustomStringStreamReadThruWrapper inworld_StatusOr_CustomStringStreamReadThruWrapper;

typedef struct SwigObj_inworld_CustomStringStreamReadThruExecutor inworld_CustomStringStreamReadThruExecutor;

typedef struct SwigObj_inworld_CustomStringStreamReadThruWrapper inworld_CustomStringStreamReadThruWrapper;

typedef struct SwigObj_inworld_ContentToStringStream inworld_ContentToStringStream;

typedef struct SwigObj_inworld_vector_CompiledIntent inworld_vector_CompiledIntent;

typedef struct SwigObj_inworld_vector_Device inworld_vector_Device;

typedef struct SwigObj_inworld_vector_Event inworld_vector_Event;

typedef struct SwigObj_inworld_vector_Intent inworld_vector_Intent;

typedef struct SwigObj_inworld_vector_IntentMatch inworld_vector_IntentMatch;

typedef struct SwigObj_inworld_vector_KeywordMatch inworld_vector_KeywordMatch;

typedef struct SwigObj_inworld_vector_KeywordGroup inworld_vector_KeywordGroup;

typedef struct SwigObj_inworld_vector_PhraseMatch inworld_vector_PhraseMatch;

typedef struct SwigObj_inworld_vector_KnowledgeRecord inworld_vector_KnowledgeRecord;

typedef struct SwigObj_inworld_vector_KnowledgeCollection inworld_vector_KnowledgeCollection;

typedef struct SwigObj_inworld_vector_LLMRoutingConfig inworld_vector_LLMRoutingConfig;

typedef struct SwigObj_inworld_vector_TopicThreshold inworld_vector_TopicThreshold;

typedef struct SwigObj_inworld_vector_DetectedTopic inworld_vector_DetectedTopic;

typedef struct SwigObj_inworld_vector_DictionaryRule inworld_vector_DictionaryRule;

typedef struct SwigObj_inworld_vector_Entity inworld_vector_Entity;

typedef struct SwigObj_inworld_vector_EntityMatch inworld_vector_EntityMatch;

typedef struct SwigObj_inworld_vector_vector_float inworld_vector_vector_float;

typedef struct SwigObj_inworld_vector_string inworld_vector_string;

typedef struct SwigObj_inworld_vector_map_string_string inworld_vector_map_string_string;

typedef struct SwigObj_inworld_map_string_string inworld_map_string_string;

typedef struct SwigObj_inworld_optional_BatchProcessingOptions inworld_optional_BatchProcessingOptions;

typedef struct SwigObj_inworld_Span inworld_Span;

typedef struct SwigObj_inworld_SpanDataEvent inworld_SpanDataEvent;

typedef struct SwigObj_inworld_SpanData inworld_SpanData;

enum inworld_ExporterType {
  inworld_ExporterType_kLocal,
  inworld_ExporterType_kRemote
};

typedef struct SwigObj_inworld_BatchProcessingOptions inworld_BatchProcessingOptions;

typedef struct SwigObj_inworld_TracerConfig inworld_TracerConfig;

enum inworld_LogLevel {
  inworld_LogLevel_kTrace,
  inworld_LogLevel_kDebug,
  inworld_LogLevel_kInfo,
  inworld_LogLevel_kWarn,
  inworld_LogLevel_kError
};

typedef struct SwigObj_inworld_LoggerConfig inworld_LoggerConfig;

typedef struct SwigObj_inworld_MetricConfig inworld_MetricConfig;

enum inworld_MetricConfig_MetricType {
  inworld_MetricConfig_MetricType_kCounterUInt,
  inworld_MetricConfig_MetricType_kCounterDouble,
  inworld_MetricConfig_MetricType_kGaugeInt,
  inworld_MetricConfig_MetricType_kGaugeDouble,
  inworld_MetricConfig_MetricType_kHistogramUInt,
  inworld_MetricConfig_MetricType_kHistogramDouble
};

typedef struct SwigObj_inworld_TelemetryConfig inworld_TelemetryConfig;

typedef struct SwigObj_inworld_TelemetryConfigBuilder inworld_TelemetryConfigBuilder;

typedef struct SwigObj_inworld_vector_TelemetrySpan inworld_vector_TelemetrySpan;

typedef struct SwigObj_inworld_vector_SpanData inworld_vector_SpanData;

typedef struct SwigObj_inworld_vector_SpanDataEvent inworld_vector_SpanDataEvent;

typedef struct SwigObj_inworld_vector_Edge inworld_vector_Edge;

typedef struct SwigObj_inworld_vector_char inworld_vector_char;

typedef struct SwigObj_inworld_vector_float inworld_vector_float;

typedef struct SwigObj_inworld_TransformationStreamDestructor inworld_TransformationStreamDestructor;

typedef struct SwigObj_inworld_TransformationStream_BaseData_To_string inworld_TransformationStream_BaseData_To_string;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string;

typedef struct SwigObj_inworld_TransformationStream_BaseData_To_Content inworld_TransformationStream_BaseData_To_Content;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content;

typedef struct SwigObj_inworld_TransformationStream_BaseData_To_AudioChunk inworld_TransformationStream_BaseData_To_AudioChunk;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk;

typedef struct SwigObj_inworld_TransformationStream_BaseData_To_TTSOutput inworld_TransformationStream_BaseData_To_TTSOutput;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput;

typedef struct SwigObj_inworld_TransformationStream_BaseData_To_BaseData inworld_TransformationStream_BaseData_To_BaseData;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData;

typedef struct SwigObj_inworld_TransformationStream_string_To_Content inworld_TransformationStream_string_To_Content;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_Content inworld_TransformationStreamThreadedTransformExecutor_string_To_Content;

typedef struct SwigObj_inworld_TransformationStream_string_To_AudioChunk inworld_TransformationStream_string_To_AudioChunk;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk;

typedef struct SwigObj_inworld_TransformationStream_string_To_TTSOutput inworld_TransformationStream_string_To_TTSOutput;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput;

typedef struct SwigObj_inworld_TransformationStream_string_To_BaseData inworld_TransformationStream_string_To_BaseData;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData;

typedef struct SwigObj_inworld_TransformationStream_string_To_string inworld_TransformationStream_string_To_string;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_string inworld_TransformationStreamThreadedTransformExecutor_string_To_string;

typedef struct SwigObj_inworld_TransformationStream_Content_To_string inworld_TransformationStream_Content_To_string;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_string inworld_TransformationStreamThreadedTransformExecutor_Content_To_string;

typedef struct SwigObj_inworld_TransformationStream_Content_To_AudioChunk inworld_TransformationStream_Content_To_AudioChunk;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk;

typedef struct SwigObj_inworld_TransformationStream_Content_To_TTSOutput inworld_TransformationStream_Content_To_TTSOutput;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput;

typedef struct SwigObj_inworld_TransformationStream_Content_To_BaseData inworld_TransformationStream_Content_To_BaseData;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData;

typedef struct SwigObj_inworld_TransformationStream_Content_To_Content inworld_TransformationStream_Content_To_Content;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content;

typedef struct SwigObj_inworld_TransformationStream_AudioChunk_To_string inworld_TransformationStream_AudioChunk_To_string;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string;

typedef struct SwigObj_inworld_TransformationStream_AudioChunk_To_Content inworld_TransformationStream_AudioChunk_To_Content;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content;

typedef struct SwigObj_inworld_TransformationStream_AudioChunk_To_TTSOutput inworld_TransformationStream_AudioChunk_To_TTSOutput;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput;

typedef struct SwigObj_inworld_TransformationStream_AudioChunk_To_BaseData inworld_TransformationStream_AudioChunk_To_BaseData;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData;

typedef struct SwigObj_inworld_TransformationStream_AudioChunk_To_AudioChunk inworld_TransformationStream_AudioChunk_To_AudioChunk;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk;

typedef struct SwigObj_inworld_TransformationStream_TTSOutput_To_string inworld_TransformationStream_TTSOutput_To_string;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string;

typedef struct SwigObj_inworld_TransformationStream_TTSOutput_To_Content inworld_TransformationStream_TTSOutput_To_Content;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content;

typedef struct SwigObj_inworld_TransformationStream_TTSOutput_To_AudioChunk inworld_TransformationStream_TTSOutput_To_AudioChunk;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk;

typedef struct SwigObj_inworld_TransformationStream_TTSOutput_To_BaseData inworld_TransformationStream_TTSOutput_To_BaseData;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData;

typedef struct SwigObj_inworld_TransformationStream_TTSOutput_To_TTSOutput inworld_TransformationStream_TTSOutput_To_TTSOutput;

typedef struct SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput;

typedef struct SwigObj_inworld_TransformationStreamThreadedFilterExecutor_BaseData inworld_TransformationStreamThreadedFilterExecutor_BaseData;

typedef struct SwigObj_inworld_TransformationStreamThreadedFilterExecutor_string inworld_TransformationStreamThreadedFilterExecutor_string;

typedef struct SwigObj_inworld_TransformationStreamThreadedFilterExecutor_Content inworld_TransformationStreamThreadedFilterExecutor_Content;

typedef struct SwigObj_inworld_TransformationStreamThreadedFilterExecutor_AudioChunk inworld_TransformationStreamThreadedFilterExecutor_AudioChunk;

typedef struct SwigObj_inworld_TransformationStreamThreadedFilterExecutor_TTSOutput inworld_TransformationStreamThreadedFilterExecutor_TTSOutput;

typedef struct SwigObj_inworld_AgentSpeech inworld_AgentSpeech;

typedef struct SwigObj_inworld_AgentAction inworld_AgentAction;

typedef struct SwigObj_inworld_Event inworld_Event;

typedef struct SwigObj_inworld_Intent inworld_Intent;

typedef struct SwigObj_inworld_CompiledIntent inworld_CompiledIntent;

typedef struct SwigObj_inworld_StatusOr_Language inworld_StatusOr_Language;

typedef struct SwigObj_inworld_Language inworld_Language;

enum inworld_DeviceType {
  inworld_DeviceType_kCPU,
  inworld_DeviceType_kCUDA,
  inworld_DeviceType_kMetal,
  inworld_DeviceType_kROCM
};

typedef struct SwigObj_inworld_DeviceInfo inworld_DeviceInfo;

typedef struct SwigObj_inworld_Device inworld_Device;

typedef struct SwigObj_inworld_DeviceRegistry inworld_DeviceRegistry;

typedef struct SwigObj_inworld_ModelProperties inworld_ModelProperties;

typedef struct SwigObj_inworld_ModelInterface inworld_ModelInterface;

typedef struct SwigObj_inworld_TextEmbedderInterface inworld_TextEmbedderInterface;

typedef struct SwigObj_inworld_optional_LocalTextEmbedderConfig inworld_optional_LocalTextEmbedderConfig;

typedef struct SwigObj_inworld_optional_RemoteTextEmbedderConfig inworld_optional_RemoteTextEmbedderConfig;

typedef struct SwigObj_inworld_LocalTextEmbedderConfig inworld_LocalTextEmbedderConfig;

typedef struct SwigObj_inworld_RemoteTextEmbedderConfig inworld_RemoteTextEmbedderConfig;

typedef struct SwigObj_inworld_TextEmbedderCreationConfig inworld_TextEmbedderCreationConfig;

typedef struct SwigObj_inworld_TextEmbedderFactory inworld_TextEmbedderFactory;

typedef struct SwigObj_inworld_optional_float inworld_optional_float;

typedef struct SwigObj_inworld_optional_int inworld_optional_int;

typedef struct SwigObj_inworld_optional_sizet inworld_optional_sizet;

typedef struct SwigObj_inworld_optional_string inworld_optional_string;

typedef struct SwigObj_inworld_optional_UserContext inworld_optional_UserContext;

typedef struct SwigObj_inworld_AudioChunk inworld_AudioChunk;

typedef struct SwigObj_inworld_Duration inworld_Duration;

typedef struct SwigObj_inworld_SpeechSynthesisPostprocessingConfig inworld_SpeechSynthesisPostprocessingConfig;

typedef struct SwigObj_inworld_SpeechSynthesisInferenceConfig inworld_SpeechSynthesisInferenceConfig;

typedef struct SwigObj_inworld_InworldSpeechSynthesisConfig inworld_InworldSpeechSynthesisConfig;

typedef struct SwigObj_inworld_ElevenLabsSpeechSynthesisConfig inworld_ElevenLabsSpeechSynthesisConfig;

typedef struct SwigObj_inworld_QueryParams inworld_QueryParams;

enum inworld_QueryParams_OutputFormat {
  inworld_QueryParams_OutputFormat_MP3_22050_32,
  inworld_QueryParams_OutputFormat_MP3_44100_32,
  inworld_QueryParams_OutputFormat_MP3_44100_64,
  inworld_QueryParams_OutputFormat_MP3_44100_96,
  inworld_QueryParams_OutputFormat_MP3_44100_128,
  inworld_QueryParams_OutputFormat_MP3_44100_192
};

typedef struct SwigObj_inworld_RequestParams inworld_RequestParams;

enum inworld_RequestParams_TextNormalization {
  inworld_RequestParams_TextNormalization_AUTO,
  inworld_RequestParams_TextNormalization_ON,
  inworld_RequestParams_TextNormalization_OFF
};

typedef struct SwigObj_inworld_SpeechSynthesisConfig inworld_SpeechSynthesisConfig;

typedef struct SwigObj_inworld_Voice inworld_Voice;

typedef struct SwigObj_inworld_TTSInterface inworld_TTSInterface;

typedef struct SwigObj_inworld_optional_Voice inworld_optional_Voice;

typedef struct SwigObj_inworld_optional_TextGenerationConfig inworld_optional_TextGenerationConfig;

typedef struct SwigObj_inworld_optional_ToolChoice inworld_optional_ToolChoice;

typedef struct SwigObj_inworld_Vector_ChatMessage inworld_Vector_ChatMessage;

typedef struct SwigObj_inworld_Vector_Tool inworld_Vector_Tool;

typedef struct SwigObj_inworld_optional_vector_ChatMessage inworld_optional_vector_ChatMessage;

typedef struct SwigObj_inworld_optional_vector_Tool inworld_optional_vector_Tool;

typedef struct SwigObj_inworld_SpeechRecognitionConfig inworld_SpeechRecognitionConfig;

typedef struct SwigObj_inworld_STTInterface inworld_STTInterface;

typedef struct SwigObj_inworld_optional_SpeechSynthesisConfig inworld_optional_SpeechSynthesisConfig;

typedef struct SwigObj_inworld_optional_SpeechRecognitionConfig inworld_optional_SpeechRecognitionConfig;

typedef struct SwigObj_inworld_optional_TextClassifierConfig inworld_optional_TextClassifierConfig;

typedef struct SwigObj_inworld_LogitBiasVector inworld_LogitBiasVector;

typedef struct SwigObj_inworld_StatusOr_Tools inworld_StatusOr_Tools;

typedef struct SwigObj_inworld_Messages inworld_Messages;

typedef struct SwigObj_inworld_ToolCalls inworld_ToolCalls;

typedef struct SwigObj_inworld_ContentItems inworld_ContentItems;

enum inworld_ResponseFormat {
  inworld_ResponseFormat_kText = 1,
  inworld_ResponseFormat_kJson = 2,
  inworld_ResponseFormat_kJsonSchema = 3
};

typedef struct SwigObj_inworld_LogitBias inworld_LogitBias;

typedef struct SwigObj_inworld_TextGenerationConfig inworld_TextGenerationConfig;

typedef struct SwigObj_inworld_Tool inworld_Tool;

typedef struct SwigObj_inworld_FunctionChoice inworld_FunctionChoice;

typedef struct SwigObj_inworld_ToolChoice inworld_ToolChoice;

typedef struct SwigObj_inworld_ToolCall inworld_ToolCall;

typedef struct SwigObj_inworld_ImageUrl inworld_ImageUrl;

typedef struct SwigObj_inworld_ContentItem inworld_ContentItem;

typedef struct SwigObj_inworld_Message inworld_Message;

typedef struct SwigObj_inworld_Content inworld_Content;

typedef struct SwigObj_inworld_LLMInterface inworld_LLMInterface;

typedef struct SwigObj_inworld_optional_LocalLLMConfig inworld_optional_LocalLLMConfig;

typedef struct SwigObj_inworld_optional_RemoteLLMConfig inworld_optional_RemoteLLMConfig;

typedef struct SwigObj_inworld_LocalLLMConfig inworld_LocalLLMConfig;

typedef struct SwigObj_inworld_RemoteLLMConfig inworld_RemoteLLMConfig;

typedef struct SwigObj_inworld_LLMCreationConfig inworld_LLMCreationConfig;

typedef struct SwigObj_inworld_LLMFactory inworld_LLMFactory;

typedef struct SwigObj_inworld_LLMRoutingHelper inworld_LLMRoutingHelper;

typedef struct SwigObj_inworld_LLMRoutingConfig inworld_LLMRoutingConfig;

typedef struct SwigObj_inworld_LLMRoutingCreationConfig inworld_LLMRoutingCreationConfig;

typedef struct SwigObj_inworld_LLMRouting inworld_LLMRouting;

typedef struct SwigObj_inworld_KnowledgeRecord inworld_KnowledgeRecord;

typedef struct SwigObj_inworld_KnowledgeCollection inworld_KnowledgeCollection;

typedef struct SwigObj_inworld_RetrievalConfig inworld_RetrievalConfig;

typedef struct SwigObj_inworld_KnowledgeRetrieverInterface inworld_KnowledgeRetrieverInterface;

typedef struct SwigObj_inworld_File inworld_File;

enum inworld_File_Type {
  inworld_File_Type_kPdf,
  inworld_File_Type_kTxt
};

typedef struct SwigObj_inworld_FileContent inworld_FileContent;

typedef struct SwigObj_inworld_ParsingConfig inworld_ParsingConfig;

typedef struct SwigObj_inworld_KnowledgeCompileConfig inworld_KnowledgeCompileConfig;

typedef struct SwigObj_inworld_KnowledgeInterface inworld_KnowledgeInterface;

typedef struct SwigObj_inworld_optional_LocalKnowledgeConfig inworld_optional_LocalKnowledgeConfig;

typedef struct SwigObj_inworld_optional_RemoteKnowledgeConfig inworld_optional_RemoteKnowledgeConfig;

typedef struct SwigObj_inworld_LocalKnowledgeConfig inworld_LocalKnowledgeConfig;

typedef struct SwigObj_inworld_RemoteKnowledgeConfig inworld_RemoteKnowledgeConfig;

typedef struct SwigObj_inworld_KnowledgeCreationConfig inworld_KnowledgeCreationConfig;

typedef struct SwigObj_inworld_KnowledgeFactory inworld_KnowledgeFactory;

typedef struct SwigObj_inworld_KnowledgeCollectionFactory inworld_KnowledgeCollectionFactory;

typedef struct SwigObj_inworld_KnowledgeRetrieverFactory inworld_KnowledgeRetrieverFactory;

typedef struct SwigObj_inworld_optional_RollingSummaryConfig inworld_optional_RollingSummaryConfig;

typedef struct SwigObj_inworld_optional_FlashMemoryConfig inworld_optional_FlashMemoryConfig;

typedef struct SwigObj_inworld_optional_LongTermMemoryConfig inworld_optional_LongTermMemoryConfig;

typedef struct SwigObj_inworld_RollingSummary inworld_RollingSummary;

typedef struct SwigObj_inworld_FlashMemory inworld_FlashMemory;

typedef struct SwigObj_inworld_LongTermMemory inworld_LongTermMemory;

typedef struct SwigObj_inworld_MemorySnapshot inworld_MemorySnapshot;

typedef struct SwigObj_inworld_RollingSummaryConfig inworld_RollingSummaryConfig;

typedef struct SwigObj_inworld_FlashMemoryConfig inworld_FlashMemoryConfig;

typedef struct SwigObj_inworld_LongTermMemoryConfig inworld_LongTermMemoryConfig;

typedef struct SwigObj_inworld_MemoryUpdateConfig inworld_MemoryUpdateConfig;

typedef struct SwigObj_inworld_MemoryInterface inworld_MemoryInterface;

typedef struct SwigObj_inworld_MemoryFactory inworld_MemoryFactory;

typedef struct SwigObj_inworld_IntentCompilerInterface inworld_IntentCompilerInterface;

typedef struct SwigObj_inworld_IntentCompilerFactory inworld_IntentCompilerFactory;

typedef struct SwigObj_inworld_optional_LlmMatcherConfig inworld_optional_LlmMatcherConfig;

typedef struct SwigObj_inworld_optional_TextEmbedderInterface inworld_optional_TextEmbedderInterface;

typedef struct SwigObj_inworld_optional_EmbeddingMatcherConfig inworld_optional_EmbeddingMatcherConfig;

typedef struct SwigObj_inworld_IntentMatch inworld_IntentMatch;

typedef struct SwigObj_inworld_EmbeddingMatcherConfig inworld_EmbeddingMatcherConfig;

typedef struct SwigObj_inworld_LlmMatcherConfig inworld_LlmMatcherConfig;

typedef struct SwigObj_inworld_IntentMatcherConfig inworld_IntentMatcherConfig;

typedef struct SwigObj_inworld_IntentMatcherInterface inworld_IntentMatcherInterface;

typedef struct SwigObj_inworld_IntentMatcherCreationConfig inworld_IntentMatcherCreationConfig;

typedef struct SwigObj_inworld_IntentMatcherFactory inworld_IntentMatcherFactory;

typedef struct SwigObj_inworld_KeywordGroup inworld_KeywordGroup;

typedef struct SwigObj_inworld_KeywordMatch inworld_KeywordMatch;

typedef struct SwigObj_inworld_KeywordMatcherResponse inworld_KeywordMatcherResponse;

typedef struct SwigObj_inworld_KeywordMatcherInterface inworld_KeywordMatcherInterface;

typedef struct SwigObj_inworld_KeywordMatcherFactory inworld_KeywordMatcherFactory;

typedef struct SwigObj_inworld_DictionaryRule inworld_DictionaryRule;

typedef struct SwigObj_inworld_Entity inworld_Entity;

typedef struct SwigObj_inworld_EntityMatch inworld_EntityMatch;

typedef struct SwigObj_inworld_NERInterface inworld_NERInterface;

typedef struct SwigObj_inworld_NERCreationConfig inworld_NERCreationConfig;

typedef struct SwigObj_inworld_NERFactory inworld_NERFactory;

typedef struct SwigObj_inworld_VectorClassThreshold inworld_VectorClassThreshold;

typedef struct SwigObj_inworld_TextClassifierResponseStatusOr inworld_TextClassifierResponseStatusOr;

typedef struct SwigObj_inworld_ClassThreshold inworld_ClassThreshold;

typedef struct SwigObj_inworld_TextClassifierConfig inworld_TextClassifierConfig;

typedef struct SwigObj_inworld_TextClassifierResponse inworld_TextClassifierResponse;

typedef struct SwigObj_inworld_TextClassifierInterface inworld_TextClassifierInterface;

typedef struct SwigObj_inworld_TextClassifierInterfaceSharedPtrStatusOr inworld_TextClassifierInterfaceSharedPtrStatusOr;

typedef struct SwigObj_inworld_TextClassifierCreationConfig inworld_TextClassifierCreationConfig;

typedef struct SwigObj_inworld_TextClassifierFactory inworld_TextClassifierFactory;

enum inworld_TopicName {
  inworld_TopicName_kPolitics,
  inworld_TopicName_kSubstanceUse,
  inworld_TopicName_kReligion,
  inworld_TopicName_kUnconditionalSelfHarm,
  inworld_TopicName_kUnconditionalSexualMinors,
  inworld_TopicName_kUnconditionalHateGroup,
  inworld_TopicName_kAdultSexual,
  inworld_TopicName_kViolence,
  inworld_TopicName_kAlcohol,
  inworld_TopicName_kProfanity
};

typedef struct SwigObj_inworld_TopicThreshold inworld_TopicThreshold;

typedef struct SwigObj_inworld_SafetyConfig inworld_SafetyConfig;

typedef struct SwigObj_inworld_DetectedTopic inworld_DetectedTopic;

typedef struct SwigObj_inworld_CheckSafetyResponse inworld_CheckSafetyResponse;

typedef struct SwigObj_inworld_SafetyCheckerInterface inworld_SafetyCheckerInterface;

typedef struct SwigObj_inworld_SafetyCheckerCreationConfig inworld_SafetyCheckerCreationConfig;

typedef struct SwigObj_inworld_SafetyCheckerFactory inworld_SafetyCheckerFactory;

typedef struct SwigObj_inworld_EmojiRemover inworld_EmojiRemover;

typedef struct SwigObj_inworld_SentenceStreamCreationConfig inworld_SentenceStreamCreationConfig;

typedef struct SwigObj_inworld_SentenceStream inworld_SentenceStream;

typedef struct SwigObj_inworld_SubstringRemover inworld_SubstringRemover;

typedef struct SwigObj_inworld_TextInBracketsRemover inworld_TextInBracketsRemover;

typedef struct SwigObj_inworld_optional_LocalSTTConfig inworld_optional_LocalSTTConfig;

typedef struct SwigObj_inworld_optional_RemoteSTTConfig inworld_optional_RemoteSTTConfig;

typedef struct SwigObj_inworld_optional_Language inworld_optional_Language;

typedef struct SwigObj_inworld_LocalSTTConfig inworld_LocalSTTConfig;

typedef struct SwigObj_inworld_RemoteSTTConfig inworld_RemoteSTTConfig;

typedef struct SwigObj_inworld_STTCreationConfig inworld_STTCreationConfig;

typedef struct SwigObj_inworld_STTFactory inworld_STTFactory;

typedef struct SwigObj_inworld_StreamSpeechRecognitionConfig inworld_StreamSpeechRecognitionConfig;

typedef struct SwigObj_inworld_StreamingSTTInterface inworld_StreamingSTTInterface;

typedef struct SwigObj_inworld_optional_LocalStreamingSTTConfig inworld_optional_LocalStreamingSTTConfig;

typedef struct SwigObj_inworld_optional_RemoteStreamingSTTConfig inworld_optional_RemoteStreamingSTTConfig;

typedef struct SwigObj_inworld_LocalStreamingSTTConfig inworld_LocalStreamingSTTConfig;

typedef struct SwigObj_inworld_RemoteStreamingSTTConfig inworld_RemoteStreamingSTTConfig;

typedef struct SwigObj_inworld_StreamingSTTCreationConfig inworld_StreamingSTTCreationConfig;

typedef struct SwigObj_inworld_StreamingSTTFactory inworld_StreamingSTTFactory;

typedef struct SwigObj_inworld_optional_RemoteTTSConfig inworld_optional_RemoteTTSConfig;

typedef struct SwigObj_inworld_LocalTTSConfig inworld_LocalTTSConfig;

typedef struct SwigObj_inworld_RemoteTTSConfig inworld_RemoteTTSConfig;

typedef struct SwigObj_inworld_TTSCreationConfig inworld_TTSCreationConfig;

typedef struct SwigObj_inworld_TTSFactory inworld_TTSFactory;

typedef struct SwigObj_inworld_SilenceIntervals inworld_SilenceIntervals;

typedef struct SwigObj_inworld_IntPair inworld_IntPair;

typedef struct SwigObj_inworld_VoiceActivityDetectionConfig inworld_VoiceActivityDetectionConfig;

typedef struct SwigObj_inworld_VADInterface inworld_VADInterface;

typedef struct SwigObj_inworld_LocalVADConfig inworld_LocalVADConfig;

typedef struct SwigObj_inworld_VADFactory inworld_VADFactory;

typedef struct SwigObj_inworld_AcousticEchoCancellationConfig inworld_AcousticEchoCancellationConfig;

typedef struct SwigObj_inworld_AECFilterInterface inworld_AECFilterInterface;

typedef struct SwigObj_inworld_LocalAECFilterConfig inworld_LocalAECFilterConfig;

typedef struct SwigObj_inworld_AECFilterFactory inworld_AECFilterFactory;

typedef struct SwigObj_inworld_NodeExecutionTelemetryContext inworld_NodeExecutionTelemetryContext;

typedef struct SwigObj_inworld_CancellationContext inworld_CancellationContext;

typedef struct SwigObj_inworld_ProcessContext inworld_ProcessContext;

typedef struct SwigObj_inworld_vector_BaseData inworld_vector_BaseData;

typedef struct SwigObj_inworld_vector_Text inworld_vector_Text;

typedef struct SwigObj_inworld_vector_ToolCallResult inworld_vector_ToolCallResult;

typedef struct SwigObj_inworld_StatusOr_Json inworld_StatusOr_Json;

typedef struct SwigObj_inworld_StatusOr_LLMCompletionRequest inworld_StatusOr_LLMCompletionRequest;

typedef struct SwigObj_inworld_BaseData inworld_BaseData;

typedef struct SwigObj_inworld_Text inworld_Text;

typedef struct SwigObj_inworld_Audio inworld_Audio;

typedef struct SwigObj_inworld_TTSOutput inworld_TTSOutput;

typedef struct SwigObj_inworld_PhraseMatch inworld_PhraseMatch;

typedef struct SwigObj_inworld_SafetyResult inworld_SafetyResult;

typedef struct SwigObj_inworld_MatchedKeywords inworld_MatchedKeywords;

typedef struct SwigObj_inworld_MatchedPhrases inworld_MatchedPhrases;

typedef struct SwigObj_inworld_ClassificationResult inworld_ClassificationResult;

typedef struct SwigObj_inworld_KnowledgeRecords inworld_KnowledgeRecords;

typedef struct SwigObj_inworld_Error inworld_Error;

typedef struct SwigObj_inworld_MatchedIntents inworld_MatchedIntents;

typedef struct SwigObj_inworld_GoalAdvancement inworld_GoalAdvancement;

typedef struct SwigObj_inworld_Json inworld_Json;

typedef struct SwigObj_inworld_ToolCallRequest inworld_ToolCallRequest;

typedef struct SwigObj_inworld_ListToolsResponse inworld_ListToolsResponse;

typedef struct SwigObj_inworld_LLMChatRequest inworld_LLMChatRequest;

typedef struct SwigObj_inworld_LLMChatResponse inworld_LLMChatResponse;

typedef struct SwigObj_inworld_LLMCompletionRequest inworld_LLMCompletionRequest;

typedef struct SwigObj_inworld_LLMCompletionResponse inworld_LLMCompletionResponse;

typedef struct SwigObj_inworld_ToolCallResult inworld_ToolCallResult;

typedef struct SwigObj_inworld_ToolCallResponse inworld_ToolCallResponse;

typedef struct SwigObj_inworld_TTSRequest inworld_TTSRequest;

typedef struct SwigObj_inworld_STTRequest inworld_STTRequest;

typedef struct SwigObj_inworld_CustomDataToJsonExecutor inworld_CustomDataToJsonExecutor;

typedef struct SwigObj_inworld_CustomDataDestructor inworld_CustomDataDestructor;

typedef struct SwigObj_inworld_CustomDataWrapper inworld_CustomDataWrapper;

typedef struct SwigObj_inworld_StatusOr_BaseData inworld_StatusOr_BaseData;

typedef struct SwigObj_inworld_Node inworld_Node;

typedef struct SwigObj_inworld_TypedNodeBase inworld_TypedNodeBase;

typedef struct SwigObj_inworld_CustomNodeProcessExecutor inworld_CustomNodeProcessExecutor;

typedef struct SwigObj_inworld_CustomNodeThreadedProcessExecutor inworld_CustomNodeThreadedProcessExecutor;

typedef struct SwigObj_inworld_CustomNodeDestructor inworld_CustomNodeDestructor;

typedef struct SwigObj_inworld_CustomNodeWrapper inworld_CustomNodeWrapper;

typedef struct SwigObj_inworld_TypedNode_Text_Text inworld_TypedNode_Text_Text;

typedef struct SwigObj_inworld_TypedNode_Text_Audio inworld_TypedNode_Text_Audio;

typedef struct SwigObj_inworld_TypedNode_BaseData_Text inworld_TypedNode_BaseData_Text;

typedef struct SwigObj_inworld_TypedNode_TTSOutputStream_Text_DataStream_String inworld_TypedNode_TTSOutputStream_Text_DataStream_String;

typedef struct SwigObj_inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest;

typedef struct SwigObj_inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text;

typedef struct SwigObj_inworld_TypedNode_KnowledgeRecords_Text inworld_TypedNode_KnowledgeRecords_Text;

typedef struct SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String inworld_TypedNode_Text_Variant_Text_DataStream_String;

typedef struct SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String;

typedef struct SwigObj_inworld_TypedNode_BaseData_LLMChatRequest inworld_TypedNode_BaseData_LLMChatRequest;

typedef struct SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk;

typedef struct SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse;

typedef struct SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse;

typedef struct SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest;

typedef struct SwigObj_inworld_HashSet_String inworld_HashSet_String;

typedef struct SwigObj_inworld_HashMap_StringToHashSetString inworld_HashMap_StringToHashSetString;

typedef struct SwigObj_inworld_Edge inworld_Edge;

typedef struct SwigObj_inworld_Loop inworld_Loop;

typedef struct SwigObj_inworld_HashMap_StringToNode inworld_HashMap_StringToNode;

typedef struct SwigObj_inworld_HashMap_StringToLoop inworld_HashMap_StringToLoop;

typedef struct SwigObj_inworld_CompiledGraphInterface inworld_CompiledGraphInterface;

typedef struct SwigObj_inworld_DataStore inworld_DataStore;

typedef struct SwigObj_inworld_EdgeContext inworld_EdgeContext;

typedef struct SwigObj_inworld_StatusOr_CompiledGraphInterfacePtr inworld_StatusOr_CompiledGraphInterfacePtr;

typedef struct SwigObj_inworld_StatusOr_ConfigParserPtr inworld_StatusOr_ConfigParserPtr;

typedef struct SwigObj_inworld_ConfigParser inworld_ConfigParser;

typedef struct SwigObj_inworld_Graph inworld_Graph;

typedef struct SwigObj_inworld_EdgeConditionExecutor inworld_EdgeConditionExecutor;

typedef struct SwigObj_inworld_EdgeConditionThreadedExecutor inworld_EdgeConditionThreadedExecutor;

typedef struct SwigObj_inworld_EdgeWrapper inworld_EdgeWrapper;

typedef struct SwigObj_inworld_MCPClientInterface inworld_MCPClientInterface;

typedef struct SwigObj_inworld_vector_Node inworld_vector_Node;

typedef struct SwigObj_inworld_LinearGraph inworld_LinearGraph;

typedef struct SwigObj_inworld_StatusOr_TTSOutput inworld_StatusOr_TTSOutput;

typedef struct SwigObj_inworld_DataStream_TTSOutput inworld_DataStream_TTSOutput;

typedef struct SwigObj_inworld_DataStream_String inworld_DataStream_String;

typedef struct SwigObj_inworld_DataStream_Content inworld_DataStream_Content;

typedef struct SwigObj_inworld_DataStream_AudioChunk inworld_DataStream_AudioChunk;

typedef struct SwigObj_inworld_DataStream_BaseData inworld_DataStream_BaseData;

typedef struct SwigObj_inworld_EventHistory inworld_EventHistory;

typedef struct SwigObj_inworld_StatusOr_CustomNodeWrapper inworld_StatusOr_CustomNodeWrapper;

typedef struct SwigObj_inworld_CustomNodeThreadedCreateExecutor inworld_CustomNodeThreadedCreateExecutor;

typedef struct SwigObj_inworld_HashMap_StringToString inworld_HashMap_StringToString;

typedef struct SwigObj_inworld_BTreeMap_StringToString inworld_BTreeMap_StringToString;

typedef struct SwigObj_inworld_HashMap_StringToBaseData inworld_HashMap_StringToBaseData;

typedef struct SwigObj_inworld_OptionalHashMapStringToBaseData inworld_OptionalHashMapStringToBaseData;

typedef struct SwigObj_inworld_StatusOr_ResultItem inworld_StatusOr_ResultItem;

typedef struct SwigObj_inworld_InputStream_ResultItem inworld_InputStream_ResultItem;

typedef struct SwigObj_inworld_ResultItem inworld_ResultItem;

typedef struct SwigObj_inworld_ExecutionResult inworld_ExecutionResult;

typedef struct SwigObj_inworld_UserContext inworld_UserContext;

typedef struct SwigObj_inworld_ExecutionContext inworld_ExecutionContext;

typedef struct SwigObj_inworld_ExecutorInterface inworld_ExecutorInterface;

typedef struct SwigObj_inworld_StatusOr_ExecutorInterfacePtr inworld_StatusOr_ExecutorInterfacePtr;

typedef struct SwigObj_inworld_StatusOr_GraphExecutorFactoryPtr inworld_StatusOr_GraphExecutorFactoryPtr;

typedef struct SwigObj_inworld_Optional_ThreadPoolConfig inworld_Optional_ThreadPoolConfig;

typedef struct SwigObj_inworld_GraphManagerConfig inworld_GraphManagerConfig;

enum inworld_GraphManagerConfig_EvaluationMode {
  inworld_GraphManagerConfig_EvaluationMode_IN_PROCESS_ONLY,
  inworld_GraphManagerConfig_EvaluationMode_REMOTE_ONLY
};

typedef struct SwigObj_inworld_ThreadPoolConfig inworld_ThreadPoolConfig;

enum inworld_ThreadPoolConfig_WorkerCountStrategy {
  inworld_ThreadPoolConfig_WorkerCountStrategy_FIXED,
  inworld_ThreadPoolConfig_WorkerCountStrategy_SYSTEM_CORES
};

enum inworld_ThreadPoolConfig_ThreadPoolStrategy {
  inworld_ThreadPoolConfig_ThreadPoolStrategy_DEDICATED,
  inworld_ThreadPoolConfig_ThreadPoolStrategy_SHARED
};

typedef struct SwigObj_inworld_GraphExecutorFactoryConfig inworld_GraphExecutorFactoryConfig;

typedef struct SwigObj_inworld_GraphExecutorConfig inworld_GraphExecutorConfig;

typedef struct SwigObj_inworld_GraphExecutorFactory inworld_GraphExecutorFactory;

typedef struct SwigObj_inworld_FeedbackRecorder inworld_FeedbackRecorder;

typedef struct SwigObj_inworld_MCPHttpAuthConfig inworld_MCPHttpAuthConfig;

typedef struct SwigObj_inworld_ParagonApiAuthConfig inworld_ParagonApiAuthConfig;

typedef struct SwigObj_inworld_MCPStdioAuthConfig inworld_MCPStdioAuthConfig;

typedef struct SwigObj_inworld_MCPAuthConfig inworld_MCPAuthConfig;

typedef struct SwigObj_inworld_MCPSessionCreationConfig inworld_MCPSessionCreationConfig;

typedef struct SwigObj_inworld_MCPClientCreationConfig inworld_MCPClientCreationConfig;

typedef struct SwigObj_inworld_MCPClientFactory inworld_MCPClientFactory;

typedef struct SwigObj_inworld_TypedNode_MatchedPhrases inworld_TypedNode_MatchedPhrases;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_EmbeddingMatcherNode inworld_StatusOr_SharedPtr_EmbeddingMatcherNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_MatchedPhrases inworld_StatusOr_SharedPtr_MatchedPhrases;

typedef struct SwigObj_inworld_EmbeddingMatcherNodeCreationConfig inworld_EmbeddingMatcherNodeCreationConfig;

typedef struct SwigObj_inworld_EmbeddingMatcherNodeExecutionConfig inworld_EmbeddingMatcherNodeExecutionConfig;

typedef struct SwigObj_inworld_EmbeddingMatcherNode inworld_EmbeddingMatcherNode;

typedef struct SwigObj_inworld_optional_Condition inworld_optional_Condition;

typedef struct SwigObj_inworld_Condition inworld_Condition;

typedef struct SwigObj_inworld_Goal inworld_Goal;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_GoalAdvancementNode inworld_StatusOr_SharedPtr_GoalAdvancementNode;

typedef struct SwigObj_inworld_vector_Goal inworld_vector_Goal;

typedef struct SwigObj_inworld_GoalAdvancementNodeCreationConfig inworld_GoalAdvancementNodeCreationConfig;

typedef struct SwigObj_inworld_GoalAdvancementNodeExecutionConfig inworld_GoalAdvancementNodeExecutionConfig;

typedef struct SwigObj_inworld_GoalAdvancementNode inworld_GoalAdvancementNode;

typedef struct SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__MatchedIntents_inworld__graphs__Text_t_t SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__MatchedIntents_inworld__graphs__Text_t_t;

typedef struct SWIGTYPE_std__shared_ptrT_std__optionalT_inworld__graphs__Text_t_t SWIGTYPE_std__shared_ptrT_std__optionalT_inworld__graphs__Text_t_t;

typedef struct SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__GoalAdvancement_t_t SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__GoalAdvancement_t_t;

typedef struct SwigObj_inworld_TypedNode_MatchedIntents inworld_TypedNode_MatchedIntents;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_IntentNode inworld_StatusOr_SharedPtr_IntentNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_MatchedIntents inworld_StatusOr_SharedPtr_MatchedIntents;

typedef struct SwigObj_inworld_optional_TextEmbedderCreationConfig inworld_optional_TextEmbedderCreationConfig;

typedef struct SwigObj_inworld_optional_LLMCreationConfig inworld_optional_LLMCreationConfig;

typedef struct SwigObj_inworld_IntentNodeExecutionConfig inworld_IntentNodeExecutionConfig;

typedef struct SwigObj_inworld_IntentNodeCreationConfig inworld_IntentNodeCreationConfig;

typedef struct SwigObj_inworld_IntentNode inworld_IntentNode;

typedef struct SwigObj_inworld_TypedNode_MatchedKeywords inworld_TypedNode_MatchedKeywords;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_KeywordMatcherNode inworld_StatusOr_SharedPtr_KeywordMatcherNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_MatchedKeywords inworld_StatusOr_SharedPtr_MatchedKeywords;

typedef struct SwigObj_inworld_KeywordMatcherNodeCreationConfig inworld_KeywordMatcherNodeCreationConfig;

typedef struct SwigObj_inworld_KeywordMatcherNode inworld_KeywordMatcherNode;

typedef struct SwigObj_inworld_TypedNode_KnowledgeRecords_Text_Text inworld_TypedNode_KnowledgeRecords_Text_Text;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_KnowledgeNode inworld_StatusOr_SharedPtr_KnowledgeNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_KnowledgeRecords inworld_StatusOr_SharedPtr_KnowledgeRecords;

typedef struct SwigObj_inworld_KnowledgeNodeCreationConfig inworld_KnowledgeNodeCreationConfig;

typedef struct SwigObj_inworld_KnowledgeNodeExecutionConfig inworld_KnowledgeNodeExecutionConfig;

typedef struct SwigObj_inworld_KnowledgeNode inworld_KnowledgeNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_LLMChatNode inworld_StatusOr_SharedPtr_LLMChatNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_LLMChatResponse inworld_StatusOr_SharedPtr_LLMChatResponse;

typedef struct SwigObj_inworld_optional_vector_LLMRoutingConfig inworld_optional_vector_LLMRoutingConfig;

typedef struct SwigObj_inworld_TypedNode_LLMChatResponse_VariantInput inworld_TypedNode_LLMChatResponse_VariantInput;

typedef struct SwigObj_inworld_StringTemplate inworld_StringTemplate;

typedef struct SwigObj_inworld_TextContent inworld_TextContent;

typedef struct SwigObj_inworld_ImageContent inworld_ImageContent;

typedef struct SwigObj_inworld_ChatMessageContent inworld_ChatMessageContent;

typedef struct SwigObj_inworld_ChatMessage inworld_ChatMessage;

typedef struct SwigObj_inworld_LLMChatNodeExecutionConfig inworld_LLMChatNodeExecutionConfig;

typedef struct SwigObj_inworld_LLMChatNode inworld_LLMChatNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_LLMCompletionNode inworld_StatusOr_SharedPtr_LLMCompletionNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_LLMCompletionResponse inworld_StatusOr_SharedPtr_LLMCompletionResponse;

typedef struct SwigObj_inworld_TypedNode_LLMCompletionResponse_VariantInput inworld_TypedNode_LLMCompletionResponse_VariantInput;

typedef struct SwigObj_inworld_LLMCompletionNodeExecutionConfig inworld_LLMCompletionNodeExecutionConfig;

typedef struct SwigObj_inworld_LLMCompletionNode inworld_LLMCompletionNode;

typedef struct SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Json_inworld__graphs__Text_inworld__graphs__LLMCompletionRequest_t_t SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Json_inworld__graphs__Text_inworld__graphs__LLMCompletionRequest_t_t;

typedef struct SwigObj_inworld_TypedNode_ToolCallResponse_ToolCallRequest inworld_TypedNode_ToolCallResponse_ToolCallRequest;

typedef struct SwigObj_inworld_TypedNode_ListToolsResponse_Text inworld_TypedNode_ListToolsResponse_Text;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_MCPListToolsNode inworld_StatusOr_SharedPtr_MCPListToolsNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_MCPCallToolNode inworld_StatusOr_SharedPtr_MCPCallToolNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_ToolCallResponse inworld_StatusOr_SharedPtr_ToolCallResponse;

typedef struct SwigObj_inworld_MCPListToolsNodeExecutionConfig inworld_MCPListToolsNodeExecutionConfig;

typedef struct SwigObj_inworld_MCPListToolsNode inworld_MCPListToolsNode;

typedef struct SwigObj_inworld_MCPCallToolNodeExecutionConfig inworld_MCPCallToolNodeExecutionConfig;

typedef struct SwigObj_inworld_MCPCallToolNode inworld_MCPCallToolNode;

typedef struct SwigObj_inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text;

typedef struct SwigObj_inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_MemoryUpdateNode inworld_StatusOr_SharedPtr_MemoryUpdateNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_MemoryRetrieveNode inworld_StatusOr_SharedPtr_MemoryRetrieveNode;

typedef struct SwigObj_inworld_MemoryUpdateNodeCreationConfig inworld_MemoryUpdateNodeCreationConfig;

typedef struct SwigObj_inworld_MemoryRetrieveNodeCreationConfig inworld_MemoryRetrieveNodeCreationConfig;

typedef struct SwigObj_inworld_MemoryRetrieveNodeExecutionConfig inworld_MemoryRetrieveNodeExecutionConfig;

typedef struct SwigObj_inworld_MemoryUpdateNode inworld_MemoryUpdateNode;

typedef struct SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__MemoryState_t_t SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__MemoryState_t_t;

typedef struct SwigObj_inworld_MemoryRetrieveNode inworld_MemoryRetrieveNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_RandomCannedTextNode inworld_StatusOr_SharedPtr_RandomCannedTextNode;

typedef struct SwigObj_inworld_RandomCannedTextNodeExecutionConfig inworld_RandomCannedTextNodeExecutionConfig;

typedef struct SwigObj_inworld_RandomCannedTextNode inworld_RandomCannedTextNode;

typedef struct SwigObj_inworld_TypedNode_SafetyResult inworld_TypedNode_SafetyResult;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_SafetyCheckerNode inworld_StatusOr_SharedPtr_SafetyCheckerNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_SafetyResult inworld_StatusOr_SharedPtr_SafetyResult;

typedef struct SwigObj_inworld_optional_SafetyConfig inworld_optional_SafetyConfig;

typedef struct SwigObj_inworld_SafetyCheckerNodeCreationConfig inworld_SafetyCheckerNodeCreationConfig;

typedef struct SwigObj_inworld_SafetyCheckerNodeExecutionConfig inworld_SafetyCheckerNodeExecutionConfig;

typedef struct SwigObj_inworld_SafetyCheckerNode inworld_SafetyCheckerNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_STTNode inworld_StatusOr_SharedPtr_STTNode;

typedef struct SwigObj_inworld_STTNodeExecutionConfig inworld_STTNodeExecutionConfig;

typedef struct SwigObj_inworld_STTNode inworld_STTNode;

typedef struct SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Audio_inworld__graphs__DataStreamT_inworld__AudioChunk_t_inworld__graphs__STTRequest_t_t SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Audio_inworld__graphs__DataStreamT_inworld__AudioChunk_t_inworld__graphs__STTRequest_t_t;

typedef struct SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__Text_t_t SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__Text_t_t;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_TextAggregatorNode inworld_StatusOr_SharedPtr_TextAggregatorNode;

typedef struct SwigObj_inworld_TextAggregatorNode inworld_TextAggregatorNode;

typedef struct SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Text_inworld__graphs__DataStreamT_std__string_t_inworld__graphs__LLMCompletionResponse_inworld__graphs__LLMChatResponse_t_t SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Text_inworld__graphs__DataStreamT_std__string_t_inworld__graphs__LLMCompletionResponse_inworld__graphs__LLMChatResponse_t_t;

typedef struct SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__Text_t_t SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__Text_t_t;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_TextChunkingNode inworld_StatusOr_SharedPtr_TextChunkingNode;

typedef struct SwigObj_inworld_TextChunkingNodeExecutionConfig inworld_TextChunkingNodeExecutionConfig;

typedef struct SwigObj_inworld_TextChunkingNode inworld_TextChunkingNode;

typedef struct SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Text_inworld__graphs__DataStreamT_std__string_t_inworld__graphs__LLMCompletionResponse_inworld__graphs__LLMChatResponse_t_t SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Text_inworld__graphs__DataStreamT_std__string_t_inworld__graphs__LLMCompletionResponse_inworld__graphs__LLMChatResponse_t_t;

typedef struct SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__DataStreamT_std__string_t_t_t SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__DataStreamT_std__string_t_t_t;

typedef struct SwigObj_inworld_TypedNode_ClassificationResult inworld_TypedNode_ClassificationResult;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_TextClassifierNode inworld_StatusOr_SharedPtr_TextClassifierNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_ClassificationResult inworld_StatusOr_SharedPtr_ClassificationResult;

typedef struct SwigObj_inworld_TextClassifierNodeCreationConfig inworld_TextClassifierNodeCreationConfig;

typedef struct SwigObj_inworld_TextClassifierNodeExecutionConfig inworld_TextClassifierNodeExecutionConfig;

typedef struct SwigObj_inworld_TextClassifierNode inworld_TextClassifierNode;

typedef struct SwigObj_inworld_StatusOr_SharedPtr_TTSNode inworld_StatusOr_SharedPtr_TTSNode;

typedef struct SwigObj_inworld_TTSNodeExecutionConfig inworld_TTSNodeExecutionConfig;

typedef struct SwigObj_inworld_TTSNode inworld_TTSNode;

typedef struct SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Text_inworld__graphs__DataStreamT_std__string_t_inworld__graphs__TTSRequest_t_t SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Text_inworld__graphs__DataStreamT_std__string_t_inworld__graphs__TTSRequest_t_t;

typedef struct SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__DataStreamT_inworld__graphs__TTSOutput_t_t_t SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__DataStreamT_inworld__graphs__TTSOutput_t_t_t;

typedef struct SwigObj_inworld_MemoryState inworld_MemoryState;

#ifdef __cplusplus
extern "C" {
#endif

SWIGIMPORT inworld_Status* inworld_InitializeRegistries();

SWIGIMPORT bool inworld_Status_ok(inworld_Status* carg1);

SWIGIMPORT inworld_Status* inworld_Status_createStatus(enum inworld_StatusCode carg1, const char * carg2);

SWIGIMPORT const char * inworld_Status_ToString(inworld_Status* carg1);

SWIGIMPORT inworld_Status* inworld_Status_new();

SWIGIMPORT inworld_Status* inworld_Status_copy(inworld_Status* carg1);

SWIGIMPORT void inworld_Status_delete(inworld_Status* carg1);

SWIGIMPORT inworld_StatusOr_opaque* inworld_StatusOr_opaque_new();

SWIGIMPORT inworld_StatusOr_opaque* inworld_StatusOr_opaque_new_rcpv(void ** carg1);

SWIGIMPORT inworld_StatusOr_opaque* inworld_StatusOr_opaque_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_opaque_ok(inworld_StatusOr_opaque* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_opaque_status(inworld_StatusOr_opaque* carg1);

SWIGIMPORT void * inworld_StatusOr_opaque_value(inworld_StatusOr_opaque* carg1);

SWIGIMPORT inworld_StatusOr_opaque* inworld_StatusOr_opaque_copy(inworld_StatusOr_opaque* carg1);

SWIGIMPORT void inworld_StatusOr_opaque_delete(inworld_StatusOr_opaque* carg1);

SWIGIMPORT inworld_StatusOr_int* inworld_StatusOr_int_new();

SWIGIMPORT inworld_StatusOr_int* inworld_StatusOr_int_new_rci(int carg1);

SWIGIMPORT inworld_StatusOr_int* inworld_StatusOr_int_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_int_ok(inworld_StatusOr_int* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_int_status(inworld_StatusOr_int* carg1);

SWIGIMPORT int inworld_StatusOr_int_value(inworld_StatusOr_int* carg1);

SWIGIMPORT inworld_StatusOr_int* inworld_StatusOr_int_copy(inworld_StatusOr_int* carg1);

SWIGIMPORT void inworld_StatusOr_int_delete(inworld_StatusOr_int* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_StatusOr_string_new();

SWIGIMPORT inworld_StatusOr_string* inworld_StatusOr_string_new_rcstd_string(const char * carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_StatusOr_string_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_string_ok(inworld_StatusOr_string* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_string_status(inworld_StatusOr_string* carg1);

SWIGIMPORT const char * inworld_StatusOr_string_value(inworld_StatusOr_string* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_StatusOr_string_copy(inworld_StatusOr_string* carg1);

SWIGIMPORT void inworld_StatusOr_string_delete(inworld_StatusOr_string* carg1);

SWIGIMPORT inworld_StatusOr_vector_string* inworld_StatusOr_vector_string_new();

SWIGIMPORT inworld_StatusOr_vector_string* inworld_StatusOr_vector_string_new_rcstd_vector_Sl_std_string_Sg_(inworld_vector_string* carg1);

SWIGIMPORT inworld_StatusOr_vector_string* inworld_StatusOr_vector_string_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_vector_string_ok(inworld_StatusOr_vector_string* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_vector_string_status(inworld_StatusOr_vector_string* carg1);

SWIGIMPORT inworld_vector_string* inworld_StatusOr_vector_string_value(inworld_StatusOr_vector_string* carg1);

SWIGIMPORT inworld_StatusOr_vector_string* inworld_StatusOr_vector_string_copy(inworld_StatusOr_vector_string* carg1);

SWIGIMPORT void inworld_StatusOr_vector_string_delete(inworld_StatusOr_vector_string* carg1);

SWIGIMPORT inworld_StatusOr_vector_float* inworld_StatusOr_vector_float_new();

SWIGIMPORT inworld_StatusOr_vector_float* inworld_StatusOr_vector_float_new_rcstd_vector_Sl_float_Sg_(inworld_vector_float* carg1);

SWIGIMPORT inworld_StatusOr_vector_float* inworld_StatusOr_vector_float_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_vector_float_ok(inworld_StatusOr_vector_float* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_vector_float_status(inworld_StatusOr_vector_float* carg1);

SWIGIMPORT inworld_vector_float* inworld_StatusOr_vector_float_value(inworld_StatusOr_vector_float* carg1);

SWIGIMPORT inworld_StatusOr_vector_float* inworld_StatusOr_vector_float_copy(inworld_StatusOr_vector_float* carg1);

SWIGIMPORT void inworld_StatusOr_vector_float_delete(inworld_StatusOr_vector_float* carg1);

SWIGIMPORT inworld_StatusOr_vector_vector_float* inworld_StatusOr_vector_vector_float_new();

SWIGIMPORT inworld_StatusOr_vector_vector_float* inworld_StatusOr_vector_vector_float_new_rcstd_vector_Sl_std_vector_Sl_float_Sg__Sg_(inworld_vector_vector_float* carg1);

SWIGIMPORT inworld_StatusOr_vector_vector_float* inworld_StatusOr_vector_vector_float_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_vector_vector_float_ok(inworld_StatusOr_vector_vector_float* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_vector_vector_float_status(inworld_StatusOr_vector_vector_float* carg1);

SWIGIMPORT inworld_vector_vector_float* inworld_StatusOr_vector_vector_float_value(inworld_StatusOr_vector_vector_float* carg1);

SWIGIMPORT inworld_StatusOr_vector_vector_float* inworld_StatusOr_vector_vector_float_copy(inworld_StatusOr_vector_vector_float* carg1);

SWIGIMPORT void inworld_StatusOr_vector_vector_float_delete(inworld_StatusOr_vector_vector_float* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_StatusOr_AudioChunk_new();

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_StatusOr_AudioChunk_new_rcinworld_AudioChunk(inworld_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_StatusOr_AudioChunk_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_AudioChunk_ok(inworld_StatusOr_AudioChunk* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_AudioChunk_status(inworld_StatusOr_AudioChunk* carg1);

SWIGIMPORT inworld_AudioChunk* inworld_StatusOr_AudioChunk_value(inworld_StatusOr_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_StatusOr_AudioChunk_copy(inworld_StatusOr_AudioChunk* carg1);

SWIGIMPORT void inworld_StatusOr_AudioChunk_delete(inworld_StatusOr_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_StatusOr_Content_new();

SWIGIMPORT inworld_StatusOr_Content* inworld_StatusOr_Content_new_rcinworld_Content(inworld_Content* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_StatusOr_Content_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_Content_ok(inworld_StatusOr_Content* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_Content_status(inworld_StatusOr_Content* carg1);

SWIGIMPORT inworld_Content* inworld_StatusOr_Content_value(inworld_StatusOr_Content* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_StatusOr_Content_copy(inworld_StatusOr_Content* carg1);

SWIGIMPORT void inworld_StatusOr_Content_delete(inworld_StatusOr_Content* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeCollection* inworld_StatusOr_KnowledgeCollection_new();

SWIGIMPORT inworld_StatusOr_KnowledgeCollection* inworld_StatusOr_KnowledgeCollection_new_rcinworld_KnowledgeCollection(inworld_KnowledgeCollection* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeCollection* inworld_StatusOr_KnowledgeCollection_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_KnowledgeCollection_ok(inworld_StatusOr_KnowledgeCollection* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_KnowledgeCollection_status(inworld_StatusOr_KnowledgeCollection* carg1);

SWIGIMPORT inworld_KnowledgeCollection* inworld_StatusOr_KnowledgeCollection_value(inworld_StatusOr_KnowledgeCollection* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeCollection* inworld_StatusOr_KnowledgeCollection_copy(inworld_StatusOr_KnowledgeCollection* carg1);

SWIGIMPORT void inworld_StatusOr_KnowledgeCollection_delete(inworld_StatusOr_KnowledgeCollection* carg1);

SWIGIMPORT inworld_StatusOr_MemorySnapshot* inworld_StatusOr_MemorySnapshot_new();

SWIGIMPORT inworld_StatusOr_MemorySnapshot* inworld_StatusOr_MemorySnapshot_new_rcinworld_MemorySnapshot(inworld_MemorySnapshot* carg1);

SWIGIMPORT inworld_StatusOr_MemorySnapshot* inworld_StatusOr_MemorySnapshot_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_MemorySnapshot_ok(inworld_StatusOr_MemorySnapshot* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_MemorySnapshot_status(inworld_StatusOr_MemorySnapshot* carg1);

SWIGIMPORT inworld_MemorySnapshot* inworld_StatusOr_MemorySnapshot_value(inworld_StatusOr_MemorySnapshot* carg1);

SWIGIMPORT inworld_StatusOr_MemorySnapshot* inworld_StatusOr_MemorySnapshot_copy(inworld_StatusOr_MemorySnapshot* carg1);

SWIGIMPORT void inworld_StatusOr_MemorySnapshot_delete(inworld_StatusOr_MemorySnapshot* carg1);

SWIGIMPORT inworld_StatusOr_CheckSafetyResponse* inworld_StatusOr_CheckSafetyResponse_new();

SWIGIMPORT inworld_StatusOr_CheckSafetyResponse* inworld_StatusOr_CheckSafetyResponse_new_rcinworld_CheckSafetyResponse(inworld_CheckSafetyResponse* carg1);

SWIGIMPORT inworld_StatusOr_CheckSafetyResponse* inworld_StatusOr_CheckSafetyResponse_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_CheckSafetyResponse_ok(inworld_StatusOr_CheckSafetyResponse* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_CheckSafetyResponse_status(inworld_StatusOr_CheckSafetyResponse* carg1);

SWIGIMPORT inworld_CheckSafetyResponse* inworld_StatusOr_CheckSafetyResponse_value(inworld_StatusOr_CheckSafetyResponse* carg1);

SWIGIMPORT inworld_StatusOr_CheckSafetyResponse* inworld_StatusOr_CheckSafetyResponse_copy(inworld_StatusOr_CheckSafetyResponse* carg1);

SWIGIMPORT void inworld_StatusOr_CheckSafetyResponse_delete(inworld_StatusOr_CheckSafetyResponse* carg1);

SWIGIMPORT inworld_StatusOr_SilenceIntervals* inworld_StatusOr_SilenceIntervals_new();

SWIGIMPORT inworld_StatusOr_SilenceIntervals* inworld_StatusOr_SilenceIntervals_new_rcstd_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg_(inworld_SilenceIntervals* carg1);

SWIGIMPORT inworld_StatusOr_SilenceIntervals* inworld_StatusOr_SilenceIntervals_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SilenceIntervals_ok(inworld_StatusOr_SilenceIntervals* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SilenceIntervals_status(inworld_StatusOr_SilenceIntervals* carg1);

SWIGIMPORT inworld_SilenceIntervals* inworld_StatusOr_SilenceIntervals_value(inworld_StatusOr_SilenceIntervals* carg1);

SWIGIMPORT inworld_StatusOr_SilenceIntervals* inworld_StatusOr_SilenceIntervals_copy(inworld_StatusOr_SilenceIntervals* carg1);

SWIGIMPORT void inworld_StatusOr_SilenceIntervals_delete(inworld_StatusOr_SilenceIntervals* carg1);

SWIGIMPORT inworld_StatusOr_vector_CompiledIntent* inworld_StatusOr_vector_CompiledIntent_new();

SWIGIMPORT inworld_StatusOr_vector_CompiledIntent* inworld_StatusOr_vector_CompiledIntent_new_rcstd_vector_Sl_inworld_CompiledIntent_Sg_(inworld_vector_CompiledIntent* carg1);

SWIGIMPORT inworld_StatusOr_vector_CompiledIntent* inworld_StatusOr_vector_CompiledIntent_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_vector_CompiledIntent_ok(inworld_StatusOr_vector_CompiledIntent* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_vector_CompiledIntent_status(inworld_StatusOr_vector_CompiledIntent* carg1);

SWIGIMPORT inworld_vector_CompiledIntent* inworld_StatusOr_vector_CompiledIntent_value(inworld_StatusOr_vector_CompiledIntent* carg1);

SWIGIMPORT inworld_StatusOr_vector_CompiledIntent* inworld_StatusOr_vector_CompiledIntent_copy(inworld_StatusOr_vector_CompiledIntent* carg1);

SWIGIMPORT void inworld_StatusOr_vector_CompiledIntent_delete(inworld_StatusOr_vector_CompiledIntent* carg1);

SWIGIMPORT inworld_StatusOr_vector_IntentMatch* inworld_StatusOr_vector_IntentMatch_new();

SWIGIMPORT inworld_StatusOr_vector_IntentMatch* inworld_StatusOr_vector_IntentMatch_new_rcstd_vector_Sl_inworld_IntentMatch_Sg_(inworld_vector_IntentMatch* carg1);

SWIGIMPORT inworld_StatusOr_vector_IntentMatch* inworld_StatusOr_vector_IntentMatch_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_vector_IntentMatch_ok(inworld_StatusOr_vector_IntentMatch* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_vector_IntentMatch_status(inworld_StatusOr_vector_IntentMatch* carg1);

SWIGIMPORT inworld_vector_IntentMatch* inworld_StatusOr_vector_IntentMatch_value(inworld_StatusOr_vector_IntentMatch* carg1);

SWIGIMPORT inworld_StatusOr_vector_IntentMatch* inworld_StatusOr_vector_IntentMatch_copy(inworld_StatusOr_vector_IntentMatch* carg1);

SWIGIMPORT void inworld_StatusOr_vector_IntentMatch_delete(inworld_StatusOr_vector_IntentMatch* carg1);

SWIGIMPORT inworld_StatusOr_vector_EntityMatch* inworld_StatusOr_vector_EntityMatch_new();

SWIGIMPORT inworld_StatusOr_vector_EntityMatch* inworld_StatusOr_vector_EntityMatch_new_rcstd_vector_Sl_inworld_EntityMatch_Sg_(inworld_vector_EntityMatch* carg1);

SWIGIMPORT inworld_StatusOr_vector_EntityMatch* inworld_StatusOr_vector_EntityMatch_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_vector_EntityMatch_ok(inworld_StatusOr_vector_EntityMatch* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_vector_EntityMatch_status(inworld_StatusOr_vector_EntityMatch* carg1);

SWIGIMPORT inworld_vector_EntityMatch* inworld_StatusOr_vector_EntityMatch_value(inworld_StatusOr_vector_EntityMatch* carg1);

SWIGIMPORT inworld_StatusOr_vector_EntityMatch* inworld_StatusOr_vector_EntityMatch_copy(inworld_StatusOr_vector_EntityMatch* carg1);

SWIGIMPORT void inworld_StatusOr_vector_EntityMatch_delete(inworld_StatusOr_vector_EntityMatch* carg1);

SWIGIMPORT inworld_StatusOr_vector_PhraseMatch* inworld_StatusOr_vector_PhraseMatch_new();

SWIGIMPORT inworld_StatusOr_vector_PhraseMatch* inworld_StatusOr_vector_PhraseMatch_new_rcstd_vector_Sl_inworld_graphs_PhraseMatch_Sg_(inworld_vector_PhraseMatch* carg1);

SWIGIMPORT inworld_StatusOr_vector_PhraseMatch* inworld_StatusOr_vector_PhraseMatch_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_vector_PhraseMatch_ok(inworld_StatusOr_vector_PhraseMatch* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_vector_PhraseMatch_status(inworld_StatusOr_vector_PhraseMatch* carg1);

SWIGIMPORT inworld_vector_PhraseMatch* inworld_StatusOr_vector_PhraseMatch_value(inworld_StatusOr_vector_PhraseMatch* carg1);

SWIGIMPORT inworld_StatusOr_vector_PhraseMatch* inworld_StatusOr_vector_PhraseMatch_copy(inworld_StatusOr_vector_PhraseMatch* carg1);

SWIGIMPORT void inworld_StatusOr_vector_PhraseMatch_delete(inworld_StatusOr_vector_PhraseMatch* carg1);

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_StatusOr_LLMInterface_new();

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_StatusOr_LLMInterface_new_rcstd_shared_ptr_Sl_inworld_LLMInterface_SS_const_Sg_(inworld_LLMInterface* carg1);

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_StatusOr_LLMInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_LLMInterface_ok(inworld_StatusOr_LLMInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_LLMInterface_status(inworld_StatusOr_LLMInterface* carg1);

SWIGIMPORT inworld_LLMInterface* inworld_StatusOr_LLMInterface_value(inworld_StatusOr_LLMInterface* carg1);

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_StatusOr_LLMInterface_copy(inworld_StatusOr_LLMInterface* carg1);

SWIGIMPORT void inworld_StatusOr_LLMInterface_delete(inworld_StatusOr_LLMInterface* carg1);

SWIGIMPORT inworld_StatusOr_LLMRouting* inworld_StatusOr_LLMRouting_new();

SWIGIMPORT inworld_StatusOr_LLMRouting* inworld_StatusOr_LLMRouting_new_rcstd_shared_ptr_Sl_inworld_LLMRouting_SS_const_Sg_(inworld_LLMRouting* carg1);

SWIGIMPORT inworld_StatusOr_LLMRouting* inworld_StatusOr_LLMRouting_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_LLMRouting_ok(inworld_StatusOr_LLMRouting* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_LLMRouting_status(inworld_StatusOr_LLMRouting* carg1);

SWIGIMPORT inworld_LLMRouting* inworld_StatusOr_LLMRouting_value(inworld_StatusOr_LLMRouting* carg1);

SWIGIMPORT inworld_StatusOr_LLMRouting* inworld_StatusOr_LLMRouting_copy(inworld_StatusOr_LLMRouting* carg1);

SWIGIMPORT void inworld_StatusOr_LLMRouting_delete(inworld_StatusOr_LLMRouting* carg1);

SWIGIMPORT inworld_StatusOr_STTInterface* inworld_StatusOr_STTInterface_new();

SWIGIMPORT inworld_StatusOr_STTInterface* inworld_StatusOr_STTInterface_new_rcstd_shared_ptr_Sl_inworld_STTInterface_SS_const_Sg_(inworld_STTInterface* carg1);

SWIGIMPORT inworld_StatusOr_STTInterface* inworld_StatusOr_STTInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_STTInterface_ok(inworld_StatusOr_STTInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_STTInterface_status(inworld_StatusOr_STTInterface* carg1);

SWIGIMPORT inworld_STTInterface* inworld_StatusOr_STTInterface_value(inworld_StatusOr_STTInterface* carg1);

SWIGIMPORT inworld_StatusOr_STTInterface* inworld_StatusOr_STTInterface_copy(inworld_StatusOr_STTInterface* carg1);

SWIGIMPORT void inworld_StatusOr_STTInterface_delete(inworld_StatusOr_STTInterface* carg1);

SWIGIMPORT inworld_StatusOr_StreamingSTTInterface* inworld_StatusOr_StreamingSTTInterface_new();

SWIGIMPORT inworld_StatusOr_StreamingSTTInterface* inworld_StatusOr_StreamingSTTInterface_new_rcstd_shared_ptr_Sl_inworld_StreamingSTTInterface_SS_const_Sg_(inworld_StreamingSTTInterface* carg1);

SWIGIMPORT inworld_StatusOr_StreamingSTTInterface* inworld_StatusOr_StreamingSTTInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_StreamingSTTInterface_ok(inworld_StatusOr_StreamingSTTInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_StreamingSTTInterface_status(inworld_StatusOr_StreamingSTTInterface* carg1);

SWIGIMPORT inworld_StreamingSTTInterface* inworld_StatusOr_StreamingSTTInterface_value(inworld_StatusOr_StreamingSTTInterface* carg1);

SWIGIMPORT inworld_StatusOr_StreamingSTTInterface* inworld_StatusOr_StreamingSTTInterface_copy(inworld_StatusOr_StreamingSTTInterface* carg1);

SWIGIMPORT void inworld_StatusOr_StreamingSTTInterface_delete(inworld_StatusOr_StreamingSTTInterface* carg1);

SWIGIMPORT inworld_StatusOr_TTSInterface* inworld_StatusOr_TTSInterface_new();

SWIGIMPORT inworld_StatusOr_TTSInterface* inworld_StatusOr_TTSInterface_new_rcstd_shared_ptr_Sl_inworld_TTSInterface_SS_const_Sg_(inworld_TTSInterface* carg1);

SWIGIMPORT inworld_StatusOr_TTSInterface* inworld_StatusOr_TTSInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_TTSInterface_ok(inworld_StatusOr_TTSInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_TTSInterface_status(inworld_StatusOr_TTSInterface* carg1);

SWIGIMPORT inworld_TTSInterface* inworld_StatusOr_TTSInterface_value(inworld_StatusOr_TTSInterface* carg1);

SWIGIMPORT inworld_StatusOr_TTSInterface* inworld_StatusOr_TTSInterface_copy(inworld_StatusOr_TTSInterface* carg1);

SWIGIMPORT void inworld_StatusOr_TTSInterface_delete(inworld_StatusOr_TTSInterface* carg1);

SWIGIMPORT inworld_StatusOr_VADInterface* inworld_StatusOr_VADInterface_new();

SWIGIMPORT inworld_StatusOr_VADInterface* inworld_StatusOr_VADInterface_new_rcstd_shared_ptr_Sl_inworld_VADInterface_Sg_(inworld_VADInterface* carg1);

SWIGIMPORT inworld_StatusOr_VADInterface* inworld_StatusOr_VADInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_VADInterface_ok(inworld_StatusOr_VADInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_VADInterface_status(inworld_StatusOr_VADInterface* carg1);

SWIGIMPORT inworld_VADInterface* inworld_StatusOr_VADInterface_value(inworld_StatusOr_VADInterface* carg1);

SWIGIMPORT inworld_StatusOr_VADInterface* inworld_StatusOr_VADInterface_copy(inworld_StatusOr_VADInterface* carg1);

SWIGIMPORT void inworld_StatusOr_VADInterface_delete(inworld_StatusOr_VADInterface* carg1);

SWIGIMPORT inworld_StatusOr_AECFilterInterface* inworld_StatusOr_AECFilterInterface_new();

SWIGIMPORT inworld_StatusOr_AECFilterInterface* inworld_StatusOr_AECFilterInterface_new_rcstd_shared_ptr_Sl_inworld_AECFilterInterface_Sg_(inworld_AECFilterInterface* carg1);

SWIGIMPORT inworld_StatusOr_AECFilterInterface* inworld_StatusOr_AECFilterInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_AECFilterInterface_ok(inworld_StatusOr_AECFilterInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_AECFilterInterface_status(inworld_StatusOr_AECFilterInterface* carg1);

SWIGIMPORT inworld_AECFilterInterface* inworld_StatusOr_AECFilterInterface_value(inworld_StatusOr_AECFilterInterface* carg1);

SWIGIMPORT inworld_StatusOr_AECFilterInterface* inworld_StatusOr_AECFilterInterface_copy(inworld_StatusOr_AECFilterInterface* carg1);

SWIGIMPORT void inworld_StatusOr_AECFilterInterface_delete(inworld_StatusOr_AECFilterInterface* carg1);

SWIGIMPORT inworld_StatusOr_IntentCompilerInterface* inworld_StatusOr_IntentCompilerInterface_new();

SWIGIMPORT inworld_StatusOr_IntentCompilerInterface* inworld_StatusOr_IntentCompilerInterface_new_rcstd_shared_ptr_Sl_inworld_IntentCompilerInterface_Sg_(inworld_IntentCompilerInterface* carg1);

SWIGIMPORT inworld_StatusOr_IntentCompilerInterface* inworld_StatusOr_IntentCompilerInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_IntentCompilerInterface_ok(inworld_StatusOr_IntentCompilerInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_IntentCompilerInterface_status(inworld_StatusOr_IntentCompilerInterface* carg1);

SWIGIMPORT inworld_IntentCompilerInterface* inworld_StatusOr_IntentCompilerInterface_value(inworld_StatusOr_IntentCompilerInterface* carg1);

SWIGIMPORT inworld_StatusOr_IntentCompilerInterface* inworld_StatusOr_IntentCompilerInterface_copy(inworld_StatusOr_IntentCompilerInterface* carg1);

SWIGIMPORT void inworld_StatusOr_IntentCompilerInterface_delete(inworld_StatusOr_IntentCompilerInterface* carg1);

SWIGIMPORT inworld_StatusOr_IntentMatcherInterface* inworld_StatusOr_IntentMatcherInterface_new();

SWIGIMPORT inworld_StatusOr_IntentMatcherInterface* inworld_StatusOr_IntentMatcherInterface_new_rcstd_shared_ptr_Sl_inworld_IntentMatcherInterface_Sg_(inworld_IntentMatcherInterface* carg1);

SWIGIMPORT inworld_StatusOr_IntentMatcherInterface* inworld_StatusOr_IntentMatcherInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_IntentMatcherInterface_ok(inworld_StatusOr_IntentMatcherInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_IntentMatcherInterface_status(inworld_StatusOr_IntentMatcherInterface* carg1);

SWIGIMPORT inworld_IntentMatcherInterface* inworld_StatusOr_IntentMatcherInterface_value(inworld_StatusOr_IntentMatcherInterface* carg1);

SWIGIMPORT inworld_StatusOr_IntentMatcherInterface* inworld_StatusOr_IntentMatcherInterface_copy(inworld_StatusOr_IntentMatcherInterface* carg1);

SWIGIMPORT void inworld_StatusOr_IntentMatcherInterface_delete(inworld_StatusOr_IntentMatcherInterface* carg1);

SWIGIMPORT inworld_StatusOr_KeywordMatcherInterface* inworld_StatusOr_KeywordMatcherInterface_new();

SWIGIMPORT inworld_StatusOr_KeywordMatcherInterface* inworld_StatusOr_KeywordMatcherInterface_new_rcstd_shared_ptr_Sl_inworld_KeywordMatcherInterface_Sg_(inworld_KeywordMatcherInterface* carg1);

SWIGIMPORT inworld_StatusOr_KeywordMatcherInterface* inworld_StatusOr_KeywordMatcherInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_KeywordMatcherInterface_ok(inworld_StatusOr_KeywordMatcherInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_KeywordMatcherInterface_status(inworld_StatusOr_KeywordMatcherInterface* carg1);

SWIGIMPORT inworld_KeywordMatcherInterface* inworld_StatusOr_KeywordMatcherInterface_value(inworld_StatusOr_KeywordMatcherInterface* carg1);

SWIGIMPORT inworld_StatusOr_KeywordMatcherInterface* inworld_StatusOr_KeywordMatcherInterface_copy(inworld_StatusOr_KeywordMatcherInterface* carg1);

SWIGIMPORT void inworld_StatusOr_KeywordMatcherInterface_delete(inworld_StatusOr_KeywordMatcherInterface* carg1);

SWIGIMPORT inworld_StatusOr_KeywordMatcherResponse* inworld_StatusOr_KeywordMatcherResponse_new();

SWIGIMPORT inworld_StatusOr_KeywordMatcherResponse* inworld_StatusOr_KeywordMatcherResponse_new_rcinworld_KeywordMatcherResponse(inworld_KeywordMatcherResponse* carg1);

SWIGIMPORT inworld_StatusOr_KeywordMatcherResponse* inworld_StatusOr_KeywordMatcherResponse_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_KeywordMatcherResponse_ok(inworld_StatusOr_KeywordMatcherResponse* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_KeywordMatcherResponse_status(inworld_StatusOr_KeywordMatcherResponse* carg1);

SWIGIMPORT inworld_KeywordMatcherResponse* inworld_StatusOr_KeywordMatcherResponse_value(inworld_StatusOr_KeywordMatcherResponse* carg1);

SWIGIMPORT inworld_StatusOr_KeywordMatcherResponse* inworld_StatusOr_KeywordMatcherResponse_copy(inworld_StatusOr_KeywordMatcherResponse* carg1);

SWIGIMPORT void inworld_StatusOr_KeywordMatcherResponse_delete(inworld_StatusOr_KeywordMatcherResponse* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeInterface* inworld_StatusOr_KnowledgeInterface_new();

SWIGIMPORT inworld_StatusOr_KnowledgeInterface* inworld_StatusOr_KnowledgeInterface_new_rcstd_shared_ptr_Sl_inworld_KnowledgeInterface_SS_const_Sg_(inworld_KnowledgeInterface* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeInterface* inworld_StatusOr_KnowledgeInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_KnowledgeInterface_ok(inworld_StatusOr_KnowledgeInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_KnowledgeInterface_status(inworld_StatusOr_KnowledgeInterface* carg1);

SWIGIMPORT inworld_KnowledgeInterface* inworld_StatusOr_KnowledgeInterface_value(inworld_StatusOr_KnowledgeInterface* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeInterface* inworld_StatusOr_KnowledgeInterface_copy(inworld_StatusOr_KnowledgeInterface* carg1);

SWIGIMPORT void inworld_StatusOr_KnowledgeInterface_delete(inworld_StatusOr_KnowledgeInterface* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeRetrieverInterface* inworld_StatusOr_KnowledgeRetrieverInterface_new();

SWIGIMPORT inworld_StatusOr_KnowledgeRetrieverInterface* inworld_StatusOr_KnowledgeRetrieverInterface_new_rcstd_shared_ptr_Sl_inworld_KnowledgeRetrieverInterface_Sg_(inworld_KnowledgeRetrieverInterface* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeRetrieverInterface* inworld_StatusOr_KnowledgeRetrieverInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_KnowledgeRetrieverInterface_ok(inworld_StatusOr_KnowledgeRetrieverInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_KnowledgeRetrieverInterface_status(inworld_StatusOr_KnowledgeRetrieverInterface* carg1);

SWIGIMPORT inworld_KnowledgeRetrieverInterface* inworld_StatusOr_KnowledgeRetrieverInterface_value(inworld_StatusOr_KnowledgeRetrieverInterface* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeRetrieverInterface* inworld_StatusOr_KnowledgeRetrieverInterface_copy(inworld_StatusOr_KnowledgeRetrieverInterface* carg1);

SWIGIMPORT void inworld_StatusOr_KnowledgeRetrieverInterface_delete(inworld_StatusOr_KnowledgeRetrieverInterface* carg1);

SWIGIMPORT inworld_StatusOr_MemoryInterface* inworld_StatusOr_MemoryInterface_new();

SWIGIMPORT inworld_StatusOr_MemoryInterface* inworld_StatusOr_MemoryInterface_new_rcstd_shared_ptr_Sl_inworld_MemoryInterface_Sg_(inworld_MemoryInterface* carg1);

SWIGIMPORT inworld_StatusOr_MemoryInterface* inworld_StatusOr_MemoryInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_MemoryInterface_ok(inworld_StatusOr_MemoryInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_MemoryInterface_status(inworld_StatusOr_MemoryInterface* carg1);

SWIGIMPORT inworld_MemoryInterface* inworld_StatusOr_MemoryInterface_value(inworld_StatusOr_MemoryInterface* carg1);

SWIGIMPORT inworld_StatusOr_MemoryInterface* inworld_StatusOr_MemoryInterface_copy(inworld_StatusOr_MemoryInterface* carg1);

SWIGIMPORT void inworld_StatusOr_MemoryInterface_delete(inworld_StatusOr_MemoryInterface* carg1);

SWIGIMPORT inworld_StatusOr_SafetyCheckerInterface* inworld_StatusOr_SafetyCheckerInterface_new();

SWIGIMPORT inworld_StatusOr_SafetyCheckerInterface* inworld_StatusOr_SafetyCheckerInterface_new_rcstd_shared_ptr_Sl_inworld_SafetyCheckerInterface_Sg_(inworld_SafetyCheckerInterface* carg1);

SWIGIMPORT inworld_StatusOr_SafetyCheckerInterface* inworld_StatusOr_SafetyCheckerInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SafetyCheckerInterface_ok(inworld_StatusOr_SafetyCheckerInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SafetyCheckerInterface_status(inworld_StatusOr_SafetyCheckerInterface* carg1);

SWIGIMPORT inworld_SafetyCheckerInterface* inworld_StatusOr_SafetyCheckerInterface_value(inworld_StatusOr_SafetyCheckerInterface* carg1);

SWIGIMPORT inworld_StatusOr_SafetyCheckerInterface* inworld_StatusOr_SafetyCheckerInterface_copy(inworld_StatusOr_SafetyCheckerInterface* carg1);

SWIGIMPORT void inworld_StatusOr_SafetyCheckerInterface_delete(inworld_StatusOr_SafetyCheckerInterface* carg1);

SWIGIMPORT inworld_StatusOr_TextEmbedderInterface* inworld_StatusOr_TextEmbedderInterface_new();

SWIGIMPORT inworld_StatusOr_TextEmbedderInterface* inworld_StatusOr_TextEmbedderInterface_new_rcstd_shared_ptr_Sl_inworld_TextEmbedderInterface_SS_const_Sg_(inworld_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_StatusOr_TextEmbedderInterface* inworld_StatusOr_TextEmbedderInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_TextEmbedderInterface_ok(inworld_StatusOr_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_TextEmbedderInterface_status(inworld_StatusOr_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_TextEmbedderInterface* inworld_StatusOr_TextEmbedderInterface_value(inworld_StatusOr_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_StatusOr_TextEmbedderInterface* inworld_StatusOr_TextEmbedderInterface_copy(inworld_StatusOr_TextEmbedderInterface* carg1);

SWIGIMPORT void inworld_StatusOr_TextEmbedderInterface_delete(inworld_StatusOr_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_StatusOr_EmojiRemover* inworld_StatusOr_EmojiRemover_new();

SWIGIMPORT inworld_StatusOr_EmojiRemover* inworld_StatusOr_EmojiRemover_new_rcstd_shared_ptr_Sl_inworld_EmojiRemover_Sg_(inworld_EmojiRemover* carg1);

SWIGIMPORT inworld_StatusOr_EmojiRemover* inworld_StatusOr_EmojiRemover_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_EmojiRemover_ok(inworld_StatusOr_EmojiRemover* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_EmojiRemover_status(inworld_StatusOr_EmojiRemover* carg1);

SWIGIMPORT inworld_EmojiRemover* inworld_StatusOr_EmojiRemover_value(inworld_StatusOr_EmojiRemover* carg1);

SWIGIMPORT inworld_StatusOr_EmojiRemover* inworld_StatusOr_EmojiRemover_copy(inworld_StatusOr_EmojiRemover* carg1);

SWIGIMPORT void inworld_StatusOr_EmojiRemover_delete(inworld_StatusOr_EmojiRemover* carg1);

SWIGIMPORT inworld_StatusOr_SentenceStream* inworld_StatusOr_SentenceStream_new();

SWIGIMPORT inworld_StatusOr_SentenceStream* inworld_StatusOr_SentenceStream_new_rcstd_shared_ptr_Sl_inworld_SentenceStream_Sg_(inworld_SentenceStream* carg1);

SWIGIMPORT inworld_StatusOr_SentenceStream* inworld_StatusOr_SentenceStream_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SentenceStream_ok(inworld_StatusOr_SentenceStream* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SentenceStream_status(inworld_StatusOr_SentenceStream* carg1);

SWIGIMPORT inworld_SentenceStream* inworld_StatusOr_SentenceStream_value(inworld_StatusOr_SentenceStream* carg1);

SWIGIMPORT inworld_StatusOr_SentenceStream* inworld_StatusOr_SentenceStream_copy(inworld_StatusOr_SentenceStream* carg1);

SWIGIMPORT void inworld_StatusOr_SentenceStream_delete(inworld_StatusOr_SentenceStream* carg1);

SWIGIMPORT inworld_StatusOr_SubstringRemover* inworld_StatusOr_SubstringRemover_new();

SWIGIMPORT inworld_StatusOr_SubstringRemover* inworld_StatusOr_SubstringRemover_new_rcstd_shared_ptr_Sl_inworld_SubstringRemover_Sg_(inworld_SubstringRemover* carg1);

SWIGIMPORT inworld_StatusOr_SubstringRemover* inworld_StatusOr_SubstringRemover_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SubstringRemover_ok(inworld_StatusOr_SubstringRemover* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SubstringRemover_status(inworld_StatusOr_SubstringRemover* carg1);

SWIGIMPORT inworld_SubstringRemover* inworld_StatusOr_SubstringRemover_value(inworld_StatusOr_SubstringRemover* carg1);

SWIGIMPORT inworld_StatusOr_SubstringRemover* inworld_StatusOr_SubstringRemover_copy(inworld_StatusOr_SubstringRemover* carg1);

SWIGIMPORT void inworld_StatusOr_SubstringRemover_delete(inworld_StatusOr_SubstringRemover* carg1);

SWIGIMPORT inworld_StatusOr_TextInBracketsRemover* inworld_StatusOr_TextInBracketsRemover_new();

SWIGIMPORT inworld_StatusOr_TextInBracketsRemover* inworld_StatusOr_TextInBracketsRemover_new_rcstd_shared_ptr_Sl_inworld_TextInBracketsRemover_Sg_(inworld_TextInBracketsRemover* carg1);

SWIGIMPORT inworld_StatusOr_TextInBracketsRemover* inworld_StatusOr_TextInBracketsRemover_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_TextInBracketsRemover_ok(inworld_StatusOr_TextInBracketsRemover* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_TextInBracketsRemover_status(inworld_StatusOr_TextInBracketsRemover* carg1);

SWIGIMPORT inworld_TextInBracketsRemover* inworld_StatusOr_TextInBracketsRemover_value(inworld_StatusOr_TextInBracketsRemover* carg1);

SWIGIMPORT inworld_StatusOr_TextInBracketsRemover* inworld_StatusOr_TextInBracketsRemover_copy(inworld_StatusOr_TextInBracketsRemover* carg1);

SWIGIMPORT void inworld_StatusOr_TextInBracketsRemover_delete(inworld_StatusOr_TextInBracketsRemover* carg1);

SWIGIMPORT inworld_StatusOr_ContentToStringStream* inworld_StatusOr_ContentToStringStream_new();

SWIGIMPORT inworld_StatusOr_ContentToStringStream* inworld_StatusOr_ContentToStringStream_new_rcstd_shared_ptr_Sl_inworld_ContentToStringStream_Sg_(inworld_ContentToStringStream* carg1);

SWIGIMPORT inworld_StatusOr_ContentToStringStream* inworld_StatusOr_ContentToStringStream_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_ContentToStringStream_ok(inworld_StatusOr_ContentToStringStream* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_ContentToStringStream_status(inworld_StatusOr_ContentToStringStream* carg1);

SWIGIMPORT inworld_ContentToStringStream* inworld_StatusOr_ContentToStringStream_value(inworld_StatusOr_ContentToStringStream* carg1);

SWIGIMPORT inworld_StatusOr_ContentToStringStream* inworld_StatusOr_ContentToStringStream_copy(inworld_StatusOr_ContentToStringStream* carg1);

SWIGIMPORT void inworld_StatusOr_ContentToStringStream_delete(inworld_StatusOr_ContentToStringStream* carg1);

SWIGIMPORT inworld_StatusOr_NERInterface* inworld_StatusOr_NERInterface_new();

SWIGIMPORT inworld_StatusOr_NERInterface* inworld_StatusOr_NERInterface_new_rcstd_shared_ptr_Sl_inworld_NERInterface_Sg_(inworld_NERInterface* carg1);

SWIGIMPORT inworld_StatusOr_NERInterface* inworld_StatusOr_NERInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_NERInterface_ok(inworld_StatusOr_NERInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_NERInterface_status(inworld_StatusOr_NERInterface* carg1);

SWIGIMPORT inworld_NERInterface* inworld_StatusOr_NERInterface_value(inworld_StatusOr_NERInterface* carg1);

SWIGIMPORT inworld_StatusOr_NERInterface* inworld_StatusOr_NERInterface_copy(inworld_StatusOr_NERInterface* carg1);

SWIGIMPORT void inworld_StatusOr_NERInterface_delete(inworld_StatusOr_NERInterface* carg1);

SWIGIMPORT inworld_StatusOr_CreationContext* inworld_StatusOr_CreationContext_new();

SWIGIMPORT inworld_StatusOr_CreationContext* inworld_StatusOr_CreationContext_new_rcinworld_CreationContext(inworld_CreationContext* carg1);

SWIGIMPORT inworld_StatusOr_CreationContext* inworld_StatusOr_CreationContext_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_CreationContext_ok(inworld_StatusOr_CreationContext* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_CreationContext_status(inworld_StatusOr_CreationContext* carg1);

SWIGIMPORT inworld_CreationContext* inworld_StatusOr_CreationContext_value(inworld_StatusOr_CreationContext* carg1);

SWIGIMPORT inworld_StatusOr_CreationContext* inworld_StatusOr_CreationContext_copy(inworld_StatusOr_CreationContext* carg1);

SWIGIMPORT void inworld_StatusOr_CreationContext_delete(inworld_StatusOr_CreationContext* carg1);

SWIGIMPORT inworld_StatusOr_MCPClientInterface* inworld_StatusOr_MCPClientInterface_new();

SWIGIMPORT inworld_StatusOr_MCPClientInterface* inworld_StatusOr_MCPClientInterface_new_rcstd_shared_ptr_Sl_inworld_MCPClientInterface_SS_const_Sg_(inworld_MCPClientInterface* carg1);

SWIGIMPORT inworld_StatusOr_MCPClientInterface* inworld_StatusOr_MCPClientInterface_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_MCPClientInterface_ok(inworld_StatusOr_MCPClientInterface* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_MCPClientInterface_status(inworld_StatusOr_MCPClientInterface* carg1);

SWIGIMPORT inworld_MCPClientInterface* inworld_StatusOr_MCPClientInterface_value(inworld_StatusOr_MCPClientInterface* carg1);

SWIGIMPORT inworld_StatusOr_MCPClientInterface* inworld_StatusOr_MCPClientInterface_copy(inworld_StatusOr_MCPClientInterface* carg1);

SWIGIMPORT void inworld_StatusOr_MCPClientInterface_delete(inworld_StatusOr_MCPClientInterface* carg1);

SWIGIMPORT inworld_ComponentStore* inworld_ComponentStore_new();

SWIGIMPORT void inworld_ComponentStore_delete(inworld_ComponentStore* carg1);

SWIGIMPORT void inworld_ComponentStore_Clear(inworld_ComponentStore* carg1);

SWIGIMPORT inworld_Status* inworld_ComponentStore_AddComponent_LLMInterface(inworld_ComponentStore* carg1, const char * carg2, inworld_LLMInterface* carg3);

SWIGIMPORT inworld_Status* inworld_ComponentStore_AddComponent_STTInterface(inworld_ComponentStore* carg1, const char * carg2, inworld_STTInterface* carg3);

SWIGIMPORT inworld_Status* inworld_ComponentStore_AddComponent_StreamingSTTInterface(inworld_ComponentStore* carg1, const char * carg2, inworld_StreamingSTTInterface* carg3);

SWIGIMPORT inworld_Status* inworld_ComponentStore_AddComponent_TTSInterface(inworld_ComponentStore* carg1, const char * carg2, inworld_TTSInterface* carg3);

SWIGIMPORT inworld_Status* inworld_ComponentStore_AddComponent_TextEmbedderInterface(inworld_ComponentStore* carg1, const char * carg2, inworld_TextEmbedderInterface* carg3);

SWIGIMPORT inworld_Status* inworld_ComponentStore_AddComponent_KnowledgeInterface(inworld_ComponentStore* carg1, const char * carg2, inworld_KnowledgeInterface* carg3);

SWIGIMPORT inworld_Status* inworld_ComponentStore_AddComponent_MCPClientInterface(inworld_ComponentStore* carg1, const char * carg2, inworld_MCPClientInterface* carg3);

SWIGIMPORT inworld_CreationContext* inworld_CreationContext_new_pinworld_ComponentStore(inworld_ComponentStore* carg1);

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_CreationContext_GetComponent_LLMInterface(inworld_CreationContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_STTInterface* inworld_CreationContext_GetComponent_STTInterface(inworld_CreationContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_StreamingSTTInterface* inworld_CreationContext_GetComponent_StreamingSTTInterface(inworld_CreationContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_TTSInterface* inworld_CreationContext_GetComponent_TTSInterface(inworld_CreationContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_TextEmbedderInterface* inworld_CreationContext_GetComponent_TextEmbedderInterface(inworld_CreationContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_KnowledgeInterface* inworld_CreationContext_GetComponent_KnowledgeInterface(inworld_CreationContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_MCPClientInterface* inworld_CreationContext_GetComponent_MCPClientInterface(inworld_CreationContext* carg1, const char * carg2);

SWIGIMPORT inworld_CreationContext* inworld_CreationContext_copy(inworld_CreationContext* carg1);

SWIGIMPORT void inworld_CreationContext_delete(inworld_CreationContext* carg1);

SWIGIMPORT inworld_ComponentRegistry* inworld_ComponentRegistry_GetInstance();

SWIGIMPORT bool inworld_ComponentRegistry_IsComponentRegistered(inworld_ComponentRegistry* carg1, const char * carg2);

SWIGIMPORT inworld_Status* inworld_ComponentRegistry_UnregisterComponent(inworld_ComponentRegistry* carg1, const char * carg2);

SWIGIMPORT void inworld_ComponentRegistry_Clear(inworld_ComponentRegistry* carg1);

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_ComponentRegistry_CreateComponent_LLMInterface_rcstd_string_rcinworld_CreationContext_rcinworld_LocalLLMConfig(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_LocalLLMConfig* carg4);

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_ComponentRegistry_CreateComponent_LLMInterface_rcstd_string_rcinworld_CreationContext_rcinworld_RemoteLLMConfig(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_RemoteLLMConfig* carg4);

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_ComponentRegistry_CreateComponent_LLMRouting(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_LLMRoutingCreationConfig* carg4);

SWIGIMPORT inworld_StatusOr_STTInterface* inworld_ComponentRegistry_CreateComponent_STTInterface_rcstd_string_rcinworld_CreationContext_rcinworld_LocalSTTConfig(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_LocalSTTConfig* carg4);

SWIGIMPORT inworld_StatusOr_STTInterface* inworld_ComponentRegistry_CreateComponent_STTInterface_rcstd_string_rcinworld_CreationContext_rcinworld_RemoteSTTConfig(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_RemoteSTTConfig* carg4);

SWIGIMPORT inworld_StatusOr_StreamingSTTInterface* inworld_ComponentRegistry_CreateComponent_StreamingSTTInterface_rcstd_string_rcinworld_CreationContext_rcinworld_LocalStreamingSTTConfig(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_LocalStreamingSTTConfig* carg4);

SWIGIMPORT inworld_StatusOr_StreamingSTTInterface* inworld_ComponentRegistry_CreateComponent_StreamingSTTInterface_rcstd_string_rcinworld_CreationContext_rcinworld_RemoteStreamingSTTConfig(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_RemoteStreamingSTTConfig* carg4);

SWIGIMPORT inworld_StatusOr_TTSInterface* inworld_ComponentRegistry_CreateComponent_TTSInterface(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_RemoteTTSConfig* carg4);

SWIGIMPORT inworld_StatusOr_TextEmbedderInterface* inworld_ComponentRegistry_CreateComponent_TextEmbedderInterface_rcstd_string_rcinworld_CreationContext_rcinworld_LocalTextEmbedderConfig(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_LocalTextEmbedderConfig* carg4);

SWIGIMPORT inworld_StatusOr_TextEmbedderInterface* inworld_ComponentRegistry_CreateComponent_TextEmbedderInterface_rcstd_string_rcinworld_CreationContext_rcinworld_RemoteTextEmbedderConfig(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_RemoteTextEmbedderConfig* carg4);

SWIGIMPORT inworld_StatusOr_KnowledgeInterface* inworld_ComponentRegistry_CreateComponent_KnowledgeInterface_rcstd_string_rcinworld_CreationContext_rcinworld_LocalKnowledgeConfig(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_LocalKnowledgeConfig* carg4);

SWIGIMPORT inworld_StatusOr_KnowledgeInterface* inworld_ComponentRegistry_CreateComponent_KnowledgeInterface_rcstd_string_rcinworld_CreationContext_rcinworld_RemoteKnowledgeConfig(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_RemoteKnowledgeConfig* carg4);

SWIGIMPORT inworld_StatusOr_MCPClientInterface* inworld_ComponentRegistry_CreateComponent_MCPClientInterface(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CreationContext* carg3, inworld_MCPClientCreationConfig* carg4);

SWIGIMPORT inworld_Status* inworld_ComponentRegistry_RegisterCustomEdgeCondition_rcstd_string_rcinworld_swig_helpers_EdgeConditionExecutor(inworld_ComponentRegistry* carg1, const char * carg2, inworld_EdgeConditionExecutor* carg3);

SWIGIMPORT inworld_Status* inworld_ComponentRegistry_RegisterCustomEdgeCondition_rcstd_string_rcinworld_swig_helpers_EdgeConditionThreadedExecutor(inworld_ComponentRegistry* carg1, const char * carg2, inworld_EdgeConditionThreadedExecutor* carg3);

SWIGIMPORT inworld_Status* inworld_ComponentRegistry_RegisterCustomNode(inworld_ComponentRegistry* carg1, const char * carg2, inworld_CustomNodeThreadedCreateExecutor* carg3);

SWIGIMPORT inworld_vector_StatusCode* inworld_vector_StatusCode_new();

SWIGIMPORT inworld_vector_StatusCode* inworld_vector_StatusCode_copy(inworld_vector_StatusCode* carg1);

SWIGIMPORT size_t inworld_vector_StatusCode_size(inworld_vector_StatusCode* carg1);

SWIGIMPORT size_t inworld_vector_StatusCode_capacity(inworld_vector_StatusCode* carg1);

SWIGIMPORT void inworld_vector_StatusCode_reserve(inworld_vector_StatusCode* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_StatusCode_empty(inworld_vector_StatusCode* carg1);

SWIGIMPORT void inworld_vector_StatusCode_clear(inworld_vector_StatusCode* carg1);

SWIGIMPORT void inworld_vector_StatusCode_push_back(inworld_vector_StatusCode* carg1, enum inworld_StatusCode* carg2);

SWIGIMPORT enum inworld_StatusCode* inworld_vector_StatusCode_get(inworld_vector_StatusCode* carg1, int carg2);

SWIGIMPORT void inworld_vector_StatusCode_set(inworld_vector_StatusCode* carg1, int carg2, enum inworld_StatusCode* carg3);

SWIGIMPORT void inworld_vector_StatusCode_delete(inworld_vector_StatusCode* carg1);

SWIGIMPORT void inworld_NodeExecutionConfig_report_to_client_set(inworld_NodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_NodeExecutionConfig_report_to_client_get(inworld_NodeExecutionConfig* carg1);

SWIGIMPORT void inworld_NodeExecutionConfig_properties_set(inworld_NodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_NodeExecutionConfig_properties_get(inworld_NodeExecutionConfig* carg1);

SWIGIMPORT void inworld_NodeExecutionConfig_delete(inworld_NodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_NodeExecutionConfig_is_valid(inworld_NodeExecutionConfig* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_NodeExecutionConfig_toJsonString(inworld_NodeExecutionConfig* carg1);

SWIGIMPORT inworld_NodeExecutionConfig* inworld_NodeExecutionConfig_CreateWithReportFlag(bool carg1);

SWIGIMPORT inworld_NodeExecutionConfig* inworld_NodeExecutionConfig_CreateWithProperties(bool carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_StatusOr_CustomConfigWrapper* inworld_StatusOr_CustomConfigWrapper_new();

SWIGIMPORT inworld_StatusOr_CustomConfigWrapper* inworld_StatusOr_CustomConfigWrapper_new_rcstd_shared_ptr_Sl_inworld_swig_helpers_CustomConfigWrapper_Sg_(inworld_CustomConfigWrapper* carg1);

SWIGIMPORT inworld_StatusOr_CustomConfigWrapper* inworld_StatusOr_CustomConfigWrapper_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_CustomConfigWrapper_ok(inworld_StatusOr_CustomConfigWrapper* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_CustomConfigWrapper_status(inworld_StatusOr_CustomConfigWrapper* carg1);

SWIGIMPORT inworld_CustomConfigWrapper* inworld_StatusOr_CustomConfigWrapper_value(inworld_StatusOr_CustomConfigWrapper* carg1);

SWIGIMPORT inworld_StatusOr_CustomConfigWrapper* inworld_StatusOr_CustomConfigWrapper_copy(inworld_StatusOr_CustomConfigWrapper* carg1);

SWIGIMPORT void inworld_StatusOr_CustomConfigWrapper_delete(inworld_StatusOr_CustomConfigWrapper* carg1);

SWIGIMPORT inworld_StatusOr_CustomExecutionConfigWrapper* inworld_StatusOr_CustomExecutionConfigWrapper_new();

SWIGIMPORT inworld_StatusOr_CustomExecutionConfigWrapper* inworld_StatusOr_CustomExecutionConfigWrapper_new_rcstd_shared_ptr_Sl_inworld_swig_helpers_CustomExecutionConfigWrapper_Sg_(inworld_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT inworld_StatusOr_CustomExecutionConfigWrapper* inworld_StatusOr_CustomExecutionConfigWrapper_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_CustomExecutionConfigWrapper_ok(inworld_StatusOr_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_CustomExecutionConfigWrapper_status(inworld_StatusOr_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT inworld_CustomExecutionConfigWrapper* inworld_StatusOr_CustomExecutionConfigWrapper_value(inworld_StatusOr_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT inworld_StatusOr_CustomExecutionConfigWrapper* inworld_StatusOr_CustomExecutionConfigWrapper_copy(inworld_StatusOr_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT void inworld_StatusOr_CustomExecutionConfigWrapper_delete(inworld_StatusOr_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT inworld_vector_CustomConfigWrapper* inworld_vector_CustomConfigWrapper_new();

SWIGIMPORT inworld_vector_CustomConfigWrapper* inworld_vector_CustomConfigWrapper_copy(inworld_vector_CustomConfigWrapper* carg1);

SWIGIMPORT size_t inworld_vector_CustomConfigWrapper_size(inworld_vector_CustomConfigWrapper* carg1);

SWIGIMPORT size_t inworld_vector_CustomConfigWrapper_capacity(inworld_vector_CustomConfigWrapper* carg1);

SWIGIMPORT void inworld_vector_CustomConfigWrapper_reserve(inworld_vector_CustomConfigWrapper* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_CustomConfigWrapper_empty(inworld_vector_CustomConfigWrapper* carg1);

SWIGIMPORT void inworld_vector_CustomConfigWrapper_clear(inworld_vector_CustomConfigWrapper* carg1);

SWIGIMPORT void inworld_vector_CustomConfigWrapper_push_back(inworld_vector_CustomConfigWrapper* carg1, inworld_CustomConfigWrapper* carg2);

SWIGIMPORT inworld_CustomConfigWrapper* inworld_vector_CustomConfigWrapper_get(inworld_vector_CustomConfigWrapper* carg1, int carg2);

SWIGIMPORT void inworld_vector_CustomConfigWrapper_set(inworld_vector_CustomConfigWrapper* carg1, int carg2, inworld_CustomConfigWrapper* carg3);

SWIGIMPORT inworld_CustomConfigWrapper* inworld_vector_CustomConfigWrapper_safe_get(inworld_vector_CustomConfigWrapper* carg1, size_t carg2);

SWIGIMPORT void inworld_vector_CustomConfigWrapper_delete(inworld_vector_CustomConfigWrapper* carg1);

SWIGIMPORT inworld_vector_CustomExecutionConfigWrapper* inworld_vector_CustomExecutionConfigWrapper_new();

SWIGIMPORT inworld_vector_CustomExecutionConfigWrapper* inworld_vector_CustomExecutionConfigWrapper_copy(inworld_vector_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT size_t inworld_vector_CustomExecutionConfigWrapper_size(inworld_vector_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT size_t inworld_vector_CustomExecutionConfigWrapper_capacity(inworld_vector_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT void inworld_vector_CustomExecutionConfigWrapper_reserve(inworld_vector_CustomExecutionConfigWrapper* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_CustomExecutionConfigWrapper_empty(inworld_vector_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT void inworld_vector_CustomExecutionConfigWrapper_clear(inworld_vector_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT void inworld_vector_CustomExecutionConfigWrapper_push_back(inworld_vector_CustomExecutionConfigWrapper* carg1, inworld_CustomExecutionConfigWrapper* carg2);

SWIGIMPORT inworld_CustomExecutionConfigWrapper* inworld_vector_CustomExecutionConfigWrapper_get(inworld_vector_CustomExecutionConfigWrapper* carg1, int carg2);

SWIGIMPORT void inworld_vector_CustomExecutionConfigWrapper_set(inworld_vector_CustomExecutionConfigWrapper* carg1, int carg2, inworld_CustomExecutionConfigWrapper* carg3);

SWIGIMPORT inworld_CustomExecutionConfigWrapper* inworld_vector_CustomExecutionConfigWrapper_safe_get(inworld_vector_CustomExecutionConfigWrapper* carg1, size_t carg2);

SWIGIMPORT void inworld_vector_CustomExecutionConfigWrapper_delete(inworld_vector_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT inworld_SerializerRegistry* inworld_SerializerRegistry_GetInstance();

SWIGIMPORT void inworld_SerializerRegistry_Clear(inworld_SerializerRegistry* carg1);

SWIGIMPORT inworld_Status* inworld_SerializerRegistry_RegisterCustomConfig(inworld_SerializerRegistry* carg1, const char * carg2, inworld_CustomConfigThreadedDeserializeExecutor* carg3, inworld_CustomConfigThreadedSerializeExecutor* carg4);

SWIGIMPORT inworld_Status* inworld_SerializerRegistry_RegisterCustomExecutionConfig(inworld_SerializerRegistry* carg1, const char * carg2, inworld_CustomExecutionConfigThreadedDeserializeExecutor* carg3, inworld_CustomExecutionConfigThreadedSerializeExecutor* carg4);

SWIGIMPORT inworld_StatusOr_CustomConfigWrapper* inworld_SerializerRegistry_DeserializeCustomConfig(inworld_SerializerRegistry* carg1, const char * carg2, const char * carg3);

SWIGIMPORT inworld_StatusOr_string* inworld_SerializerRegistry_SerializeCustomConfig(inworld_SerializerRegistry* carg1, const char * carg2, inworld_CustomConfigWrapper* carg3);

SWIGIMPORT inworld_StatusOr_CustomExecutionConfigWrapper* inworld_SerializerRegistry_DeserializeCustomExecutionConfig(inworld_SerializerRegistry* carg1, const char * carg2, const char * carg3);

SWIGIMPORT inworld_StatusOr_string* inworld_SerializerRegistry_SerializeCustomExecutionConfig(inworld_SerializerRegistry* carg1, const char * carg2, inworld_CustomExecutionConfigWrapper* carg3);

SWIGIMPORT inworld_ConfigWrapperDestructor* inworld_ConfigWrapperDestructor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_ConfigWrapperDestructor_delete(inworld_ConfigWrapperDestructor* carg1);

SWIGIMPORT inworld_ConfigWrapperDestructor* inworld_ConfigWrapperDestructor_copy(inworld_ConfigWrapperDestructor* carg1);

SWIGIMPORT inworld_CustomConfigWrapper* inworld_CustomConfigWrapper_new(const char * carg1, void * carg2, inworld_ConfigWrapperDestructor* carg3);

SWIGIMPORT void inworld_CustomConfigWrapper_delete(inworld_CustomConfigWrapper* carg1);

SWIGIMPORT const char * inworld_CustomConfigWrapper_type_id(inworld_CustomConfigWrapper* carg1);

SWIGIMPORT void * inworld_CustomConfigWrapper_value(inworld_CustomConfigWrapper* carg1);

SWIGIMPORT inworld_CustomExecutionConfigWrapper* inworld_CustomExecutionConfigWrapper_new(const char * carg1, void * carg2, bool carg3, inworld_ConfigWrapperDestructor* carg4);

SWIGIMPORT void inworld_CustomExecutionConfigWrapper_delete(inworld_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT const char * inworld_CustomExecutionConfigWrapper_type_id(inworld_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT void * inworld_CustomExecutionConfigWrapper_value(inworld_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT void inworld_CustomExecutionConfigWrapper_report_to_client_set(inworld_CustomExecutionConfigWrapper* carg1, bool carg2);

SWIGIMPORT bool inworld_CustomExecutionConfigWrapper_report_to_client_get(inworld_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT void inworld_CustomExecutionConfigWrapper_properties_set(inworld_CustomExecutionConfigWrapper* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_CustomExecutionConfigWrapper_properties_get(inworld_CustomExecutionConfigWrapper* carg1);

SWIGIMPORT inworld_CustomConfigThreadedSerializeExecutor* inworld_CustomConfigThreadedSerializeExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_CustomConfigThreadedSerializeExecutor_delete(inworld_CustomConfigThreadedSerializeExecutor* carg1);

SWIGIMPORT inworld_CustomConfigWrapper* inworld_CustomConfigThreadedSerializeExecutor_GetInput(int carg1);

SWIGIMPORT void inworld_CustomConfigThreadedSerializeExecutor_SetOutput(int carg1, const char * carg2);

SWIGIMPORT inworld_CustomConfigThreadedSerializeExecutor* inworld_CustomConfigThreadedSerializeExecutor_copy(inworld_CustomConfigThreadedSerializeExecutor* carg1);

SWIGIMPORT inworld_CustomConfigThreadedDeserializeExecutor* inworld_CustomConfigThreadedDeserializeExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_CustomConfigThreadedDeserializeExecutor_delete(inworld_CustomConfigThreadedDeserializeExecutor* carg1);

SWIGIMPORT const char * inworld_CustomConfigThreadedDeserializeExecutor_GetInput(int carg1);

SWIGIMPORT void inworld_CustomConfigThreadedDeserializeExecutor_SetOutput(int carg1, inworld_StatusOr_CustomConfigWrapper* carg2);

SWIGIMPORT inworld_CustomConfigThreadedDeserializeExecutor* inworld_CustomConfigThreadedDeserializeExecutor_copy(inworld_CustomConfigThreadedDeserializeExecutor* carg1);

SWIGIMPORT inworld_CustomExecutionConfigThreadedSerializeExecutor* inworld_CustomExecutionConfigThreadedSerializeExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_CustomExecutionConfigThreadedSerializeExecutor_delete(inworld_CustomExecutionConfigThreadedSerializeExecutor* carg1);

SWIGIMPORT inworld_CustomExecutionConfigWrapper* inworld_CustomExecutionConfigThreadedSerializeExecutor_GetInput(int carg1);

SWIGIMPORT void inworld_CustomExecutionConfigThreadedSerializeExecutor_SetOutput(int carg1, const char * carg2);

SWIGIMPORT inworld_CustomExecutionConfigThreadedSerializeExecutor* inworld_CustomExecutionConfigThreadedSerializeExecutor_copy(inworld_CustomExecutionConfigThreadedSerializeExecutor* carg1);

SWIGIMPORT inworld_CustomExecutionConfigThreadedDeserializeExecutor* inworld_CustomExecutionConfigThreadedDeserializeExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_CustomExecutionConfigThreadedDeserializeExecutor_delete(inworld_CustomExecutionConfigThreadedDeserializeExecutor* carg1);

SWIGIMPORT const char * inworld_CustomExecutionConfigThreadedDeserializeExecutor_GetInput(int carg1);

SWIGIMPORT void inworld_CustomExecutionConfigThreadedDeserializeExecutor_SetOutput(int carg1, inworld_StatusOr_CustomExecutionConfigWrapper* carg2);

SWIGIMPORT inworld_CustomExecutionConfigThreadedDeserializeExecutor* inworld_CustomExecutionConfigThreadedDeserializeExecutor_copy(inworld_CustomExecutionConfigThreadedDeserializeExecutor* carg1);

SWIGIMPORT void inworld_InputStream_TTSOutput_delete(inworld_InputStream_TTSOutput* carg1);

SWIGIMPORT bool inworld_InputStream_TTSOutput_HasNext(inworld_InputStream_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_InputStream_TTSOutput_Read(inworld_InputStream_TTSOutput* carg1);

SWIGIMPORT void inworld_InputStream_TTSOutput_Cancel(inworld_InputStream_TTSOutput* carg1);

SWIGIMPORT bool inworld_InputStream_TTSOutput_is_valid(inworld_InputStream_TTSOutput* carg1);

SWIGIMPORT void inworld_InputStream_Content_delete(inworld_InputStream_Content* carg1);

SWIGIMPORT bool inworld_InputStream_Content_HasNext(inworld_InputStream_Content* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_InputStream_Content_Read(inworld_InputStream_Content* carg1);

SWIGIMPORT void inworld_InputStream_Content_Cancel(inworld_InputStream_Content* carg1);

SWIGIMPORT bool inworld_InputStream_Content_is_valid(inworld_InputStream_Content* carg1);

SWIGIMPORT void inworld_InputStream_string_delete(inworld_InputStream_string* carg1);

SWIGIMPORT bool inworld_InputStream_string_HasNext(inworld_InputStream_string* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_InputStream_string_Read(inworld_InputStream_string* carg1);

SWIGIMPORT void inworld_InputStream_string_Cancel(inworld_InputStream_string* carg1);

SWIGIMPORT bool inworld_InputStream_string_is_valid(inworld_InputStream_string* carg1);

SWIGIMPORT void inworld_InputStream_AudioChunk_delete(inworld_InputStream_AudioChunk* carg1);

SWIGIMPORT bool inworld_InputStream_AudioChunk_HasNext(inworld_InputStream_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_InputStream_AudioChunk_Read(inworld_InputStream_AudioChunk* carg1);

SWIGIMPORT void inworld_InputStream_AudioChunk_Cancel(inworld_InputStream_AudioChunk* carg1);

SWIGIMPORT bool inworld_InputStream_AudioChunk_is_valid(inworld_InputStream_AudioChunk* carg1);

SWIGIMPORT void inworld_InputStream_BaseData_delete(inworld_InputStream_BaseData* carg1);

SWIGIMPORT bool inworld_InputStream_BaseData_HasNext(inworld_InputStream_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_InputStream_BaseData_Read(inworld_InputStream_BaseData* carg1);

SWIGIMPORT void inworld_InputStream_BaseData_Cancel(inworld_InputStream_BaseData* carg1);

SWIGIMPORT bool inworld_InputStream_BaseData_is_valid(inworld_InputStream_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_StatusOr_InputStream_string_new();

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_StatusOr_InputStream_string_new_rcstd_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg_(inworld_InputStream_string* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_StatusOr_InputStream_string_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_InputStream_string_ok(inworld_StatusOr_InputStream_string* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_InputStream_string_status(inworld_StatusOr_InputStream_string* carg1);

SWIGIMPORT inworld_InputStream_string* inworld_StatusOr_InputStream_string_value(inworld_StatusOr_InputStream_string* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_StatusOr_InputStream_string_copy(inworld_StatusOr_InputStream_string* carg1);

SWIGIMPORT void inworld_StatusOr_InputStream_string_delete(inworld_StatusOr_InputStream_string* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_StatusOr_InputStream_AudioChunk_new();

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_StatusOr_InputStream_AudioChunk_new_rcstd_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg_(inworld_InputStream_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_StatusOr_InputStream_AudioChunk_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_InputStream_AudioChunk_ok(inworld_StatusOr_InputStream_AudioChunk* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_InputStream_AudioChunk_status(inworld_StatusOr_InputStream_AudioChunk* carg1);

SWIGIMPORT inworld_InputStream_AudioChunk* inworld_StatusOr_InputStream_AudioChunk_value(inworld_StatusOr_InputStream_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_StatusOr_InputStream_AudioChunk_copy(inworld_StatusOr_InputStream_AudioChunk* carg1);

SWIGIMPORT void inworld_StatusOr_InputStream_AudioChunk_delete(inworld_StatusOr_InputStream_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_StatusOr_InputStream_Content_new();

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_StatusOr_InputStream_Content_new_rcstd_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg_(inworld_InputStream_Content* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_StatusOr_InputStream_Content_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_InputStream_Content_ok(inworld_StatusOr_InputStream_Content* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_InputStream_Content_status(inworld_StatusOr_InputStream_Content* carg1);

SWIGIMPORT inworld_InputStream_Content* inworld_StatusOr_InputStream_Content_value(inworld_StatusOr_InputStream_Content* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_StatusOr_InputStream_Content_copy(inworld_StatusOr_InputStream_Content* carg1);

SWIGIMPORT void inworld_StatusOr_InputStream_Content_delete(inworld_StatusOr_InputStream_Content* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_StatusOr_InputStream_BaseData_new();

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_StatusOr_InputStream_BaseData_new_rcstd_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg_(inworld_InputStream_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_StatusOr_InputStream_BaseData_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_InputStream_BaseData_ok(inworld_StatusOr_InputStream_BaseData* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_InputStream_BaseData_status(inworld_StatusOr_InputStream_BaseData* carg1);

SWIGIMPORT inworld_InputStream_BaseData* inworld_StatusOr_InputStream_BaseData_value(inworld_StatusOr_InputStream_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_StatusOr_InputStream_BaseData_copy(inworld_StatusOr_InputStream_BaseData* carg1);

SWIGIMPORT void inworld_StatusOr_InputStream_BaseData_delete(inworld_StatusOr_InputStream_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_StatusOr_InputStream_TTSOutput_new();

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_StatusOr_InputStream_TTSOutput_new_rcstd_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg_(inworld_InputStream_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_StatusOr_InputStream_TTSOutput_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_InputStream_TTSOutput_ok(inworld_StatusOr_InputStream_TTSOutput* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_InputStream_TTSOutput_status(inworld_StatusOr_InputStream_TTSOutput* carg1);

SWIGIMPORT inworld_InputStream_TTSOutput* inworld_StatusOr_InputStream_TTSOutput_value(inworld_StatusOr_InputStream_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_StatusOr_InputStream_TTSOutput_copy(inworld_StatusOr_InputStream_TTSOutput* carg1);

SWIGIMPORT void inworld_StatusOr_InputStream_TTSOutput_delete(inworld_StatusOr_InputStream_TTSOutput* carg1);

SWIGIMPORT inworld_BlockingStream_TTSOutput* inworld_BlockingStream_TTSOutput_Create();

SWIGIMPORT void inworld_BlockingStream_TTSOutput_delete(inworld_BlockingStream_TTSOutput* carg1);

SWIGIMPORT bool inworld_BlockingStream_TTSOutput_HasNext(inworld_BlockingStream_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_BlockingStream_TTSOutput_Read(inworld_BlockingStream_TTSOutput* carg1);

SWIGIMPORT void inworld_BlockingStream_TTSOutput_Cancel(inworld_BlockingStream_TTSOutput* carg1);

SWIGIMPORT bool inworld_BlockingStream_TTSOutput_Write(inworld_BlockingStream_TTSOutput* carg1, inworld_TTSOutput* carg2);

SWIGIMPORT void inworld_BlockingStream_TTSOutput_Close(inworld_BlockingStream_TTSOutput* carg1);

SWIGIMPORT void inworld_BlockingStream_TTSOutput_Close_rcabsl_Status(inworld_BlockingStream_TTSOutput* carg1, inworld_Status* carg2);

SWIGIMPORT bool inworld_BlockingStream_TTSOutput_is_valid(inworld_BlockingStream_TTSOutput* carg1);

SWIGIMPORT inworld_BlockingStream_Content* inworld_BlockingStream_Content_Create();

SWIGIMPORT void inworld_BlockingStream_Content_delete(inworld_BlockingStream_Content* carg1);

SWIGIMPORT bool inworld_BlockingStream_Content_HasNext(inworld_BlockingStream_Content* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_BlockingStream_Content_Read(inworld_BlockingStream_Content* carg1);

SWIGIMPORT void inworld_BlockingStream_Content_Cancel(inworld_BlockingStream_Content* carg1);

SWIGIMPORT bool inworld_BlockingStream_Content_Write(inworld_BlockingStream_Content* carg1, inworld_Content* carg2);

SWIGIMPORT void inworld_BlockingStream_Content_Close(inworld_BlockingStream_Content* carg1);

SWIGIMPORT void inworld_BlockingStream_Content_Close_rcabsl_Status(inworld_BlockingStream_Content* carg1, inworld_Status* carg2);

SWIGIMPORT bool inworld_BlockingStream_Content_is_valid(inworld_BlockingStream_Content* carg1);

SWIGIMPORT inworld_BlockingStream_AudioChunk* inworld_BlockingStream_AudioChunk_Create();

SWIGIMPORT void inworld_BlockingStream_AudioChunk_delete(inworld_BlockingStream_AudioChunk* carg1);

SWIGIMPORT bool inworld_BlockingStream_AudioChunk_HasNext(inworld_BlockingStream_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_BlockingStream_AudioChunk_Read(inworld_BlockingStream_AudioChunk* carg1);

SWIGIMPORT void inworld_BlockingStream_AudioChunk_Cancel(inworld_BlockingStream_AudioChunk* carg1);

SWIGIMPORT bool inworld_BlockingStream_AudioChunk_Write(inworld_BlockingStream_AudioChunk* carg1, inworld_AudioChunk* carg2);

SWIGIMPORT void inworld_BlockingStream_AudioChunk_Close(inworld_BlockingStream_AudioChunk* carg1);

SWIGIMPORT void inworld_BlockingStream_AudioChunk_Close_rcabsl_Status(inworld_BlockingStream_AudioChunk* carg1, inworld_Status* carg2);

SWIGIMPORT bool inworld_BlockingStream_AudioChunk_is_valid(inworld_BlockingStream_AudioChunk* carg1);

SWIGIMPORT inworld_BlockingStream_string* inworld_BlockingStream_string_Create();

SWIGIMPORT void inworld_BlockingStream_string_delete(inworld_BlockingStream_string* carg1);

SWIGIMPORT bool inworld_BlockingStream_string_HasNext(inworld_BlockingStream_string* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_BlockingStream_string_Read(inworld_BlockingStream_string* carg1);

SWIGIMPORT void inworld_BlockingStream_string_Cancel(inworld_BlockingStream_string* carg1);

SWIGIMPORT bool inworld_BlockingStream_string_Write(inworld_BlockingStream_string* carg1, const char * carg2);

SWIGIMPORT void inworld_BlockingStream_string_Close(inworld_BlockingStream_string* carg1);

SWIGIMPORT void inworld_BlockingStream_string_Close_rcabsl_Status(inworld_BlockingStream_string* carg1, inworld_Status* carg2);

SWIGIMPORT bool inworld_BlockingStream_string_is_valid(inworld_BlockingStream_string* carg1);

SWIGIMPORT inworld_BlockingStream_BaseData* inworld_BlockingStream_BaseData_Create();

SWIGIMPORT void inworld_BlockingStream_BaseData_delete(inworld_BlockingStream_BaseData* carg1);

SWIGIMPORT bool inworld_BlockingStream_BaseData_HasNext(inworld_BlockingStream_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_BlockingStream_BaseData_Read(inworld_BlockingStream_BaseData* carg1);

SWIGIMPORT void inworld_BlockingStream_BaseData_Cancel(inworld_BlockingStream_BaseData* carg1);

SWIGIMPORT bool inworld_BlockingStream_BaseData_Write(inworld_BlockingStream_BaseData* carg1, inworld_BaseData* carg2);

SWIGIMPORT void inworld_BlockingStream_BaseData_Close(inworld_BlockingStream_BaseData* carg1);

SWIGIMPORT void inworld_BlockingStream_BaseData_Close_rcabsl_Status(inworld_BlockingStream_BaseData* carg1, inworld_Status* carg2);

SWIGIMPORT bool inworld_BlockingStream_BaseData_is_valid(inworld_BlockingStream_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_CustomStringStreamReadThruWrapper* inworld_StatusOr_CustomStringStreamReadThruWrapper_new();

SWIGIMPORT inworld_StatusOr_CustomStringStreamReadThruWrapper* inworld_StatusOr_CustomStringStreamReadThruWrapper_new_rcstd_shared_ptr_Sl_inworld_swig_helpers_CustomStringStreamReadThruWrapper_Sg_(inworld_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT inworld_StatusOr_CustomStringStreamReadThruWrapper* inworld_StatusOr_CustomStringStreamReadThruWrapper_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_CustomStringStreamReadThruWrapper_ok(inworld_StatusOr_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_CustomStringStreamReadThruWrapper_status(inworld_StatusOr_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT inworld_CustomStringStreamReadThruWrapper* inworld_StatusOr_CustomStringStreamReadThruWrapper_value(inworld_StatusOr_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT inworld_StatusOr_CustomStringStreamReadThruWrapper* inworld_StatusOr_CustomStringStreamReadThruWrapper_copy(inworld_StatusOr_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT void inworld_StatusOr_CustomStringStreamReadThruWrapper_delete(inworld_StatusOr_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT inworld_CustomStringStreamReadThruExecutor* inworld_CustomStringStreamReadThruExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT inworld_CustomStringStreamReadThruExecutor* inworld_CustomStringStreamReadThruExecutor_copy(inworld_CustomStringStreamReadThruExecutor* carg1);

SWIGIMPORT void inworld_CustomStringStreamReadThruExecutor_delete(inworld_CustomStringStreamReadThruExecutor* carg1);

SWIGIMPORT inworld_StatusOr_CustomStringStreamReadThruWrapper* inworld_CustomStringStreamReadThruWrapper_Create(inworld_InputStream_string* carg1, inworld_CustomStringStreamReadThruExecutor* carg2);

SWIGIMPORT void inworld_CustomStringStreamReadThruWrapper_delete(inworld_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT bool inworld_CustomStringStreamReadThruWrapper_HasNext(inworld_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_CustomStringStreamReadThruWrapper_Read(inworld_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT void inworld_CustomStringStreamReadThruWrapper_Cancel(inworld_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT bool inworld_CustomStringStreamReadThruWrapper_is_valid(inworld_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT inworld_CustomStringStreamReadThruWrapper* inworld_CustomStringStreamReadThruWrapper_copy(inworld_CustomStringStreamReadThruWrapper* carg1);

SWIGIMPORT inworld_StatusOr_ContentToStringStream* inworld_ContentToStringStream_Create(inworld_InputStream_Content* carg1);

SWIGIMPORT void inworld_ContentToStringStream_delete(inworld_ContentToStringStream* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_ContentToStringStream_Read(inworld_ContentToStringStream* carg1);

SWIGIMPORT bool inworld_ContentToStringStream_HasNext(inworld_ContentToStringStream* carg1);

SWIGIMPORT void inworld_ContentToStringStream_Cancel(inworld_ContentToStringStream* carg1);

SWIGIMPORT bool inworld_ContentToStringStream_is_valid(inworld_ContentToStringStream* carg1);

SWIGIMPORT inworld_vector_CompiledIntent* inworld_vector_CompiledIntent_new();

SWIGIMPORT inworld_vector_CompiledIntent* inworld_vector_CompiledIntent_copy(inworld_vector_CompiledIntent* carg1);

SWIGIMPORT size_t inworld_vector_CompiledIntent_size(inworld_vector_CompiledIntent* carg1);

SWIGIMPORT size_t inworld_vector_CompiledIntent_capacity(inworld_vector_CompiledIntent* carg1);

SWIGIMPORT void inworld_vector_CompiledIntent_reserve(inworld_vector_CompiledIntent* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_CompiledIntent_empty(inworld_vector_CompiledIntent* carg1);

SWIGIMPORT void inworld_vector_CompiledIntent_clear(inworld_vector_CompiledIntent* carg1);

SWIGIMPORT void inworld_vector_CompiledIntent_push_back(inworld_vector_CompiledIntent* carg1, inworld_CompiledIntent* carg2);

SWIGIMPORT inworld_CompiledIntent* inworld_vector_CompiledIntent_get(inworld_vector_CompiledIntent* carg1, int carg2);

SWIGIMPORT void inworld_vector_CompiledIntent_set(inworld_vector_CompiledIntent* carg1, int carg2, inworld_CompiledIntent* carg3);

SWIGIMPORT void inworld_vector_CompiledIntent_delete(inworld_vector_CompiledIntent* carg1);

SWIGIMPORT inworld_vector_Device* inworld_vector_Device_new();

SWIGIMPORT inworld_vector_Device* inworld_vector_Device_copy(inworld_vector_Device* carg1);

SWIGIMPORT size_t inworld_vector_Device_size(inworld_vector_Device* carg1);

SWIGIMPORT size_t inworld_vector_Device_capacity(inworld_vector_Device* carg1);

SWIGIMPORT void inworld_vector_Device_reserve(inworld_vector_Device* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_Device_empty(inworld_vector_Device* carg1);

SWIGIMPORT void inworld_vector_Device_clear(inworld_vector_Device* carg1);

SWIGIMPORT void inworld_vector_Device_push_back(inworld_vector_Device* carg1, inworld_Device* carg2);

SWIGIMPORT inworld_Device* inworld_vector_Device_get(inworld_vector_Device* carg1, int carg2);

SWIGIMPORT void inworld_vector_Device_set(inworld_vector_Device* carg1, int carg2, inworld_Device* carg3);

SWIGIMPORT void inworld_vector_Device_delete(inworld_vector_Device* carg1);

SWIGIMPORT inworld_vector_Event* inworld_vector_Event_new();

SWIGIMPORT inworld_vector_Event* inworld_vector_Event_copy(inworld_vector_Event* carg1);

SWIGIMPORT size_t inworld_vector_Event_size(inworld_vector_Event* carg1);

SWIGIMPORT size_t inworld_vector_Event_capacity(inworld_vector_Event* carg1);

SWIGIMPORT void inworld_vector_Event_reserve(inworld_vector_Event* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_Event_empty(inworld_vector_Event* carg1);

SWIGIMPORT void inworld_vector_Event_clear(inworld_vector_Event* carg1);

SWIGIMPORT void inworld_vector_Event_push_back(inworld_vector_Event* carg1, inworld_Event* carg2);

SWIGIMPORT inworld_Event* inworld_vector_Event_get(inworld_vector_Event* carg1, int carg2);

SWIGIMPORT void inworld_vector_Event_set(inworld_vector_Event* carg1, int carg2, inworld_Event* carg3);

SWIGIMPORT void inworld_vector_Event_delete(inworld_vector_Event* carg1);

SWIGIMPORT inworld_vector_Intent* inworld_vector_Intent_new();

SWIGIMPORT inworld_vector_Intent* inworld_vector_Intent_copy(inworld_vector_Intent* carg1);

SWIGIMPORT size_t inworld_vector_Intent_size(inworld_vector_Intent* carg1);

SWIGIMPORT size_t inworld_vector_Intent_capacity(inworld_vector_Intent* carg1);

SWIGIMPORT void inworld_vector_Intent_reserve(inworld_vector_Intent* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_Intent_empty(inworld_vector_Intent* carg1);

SWIGIMPORT void inworld_vector_Intent_clear(inworld_vector_Intent* carg1);

SWIGIMPORT void inworld_vector_Intent_push_back(inworld_vector_Intent* carg1, inworld_Intent* carg2);

SWIGIMPORT inworld_Intent* inworld_vector_Intent_get(inworld_vector_Intent* carg1, int carg2);

SWIGIMPORT void inworld_vector_Intent_set(inworld_vector_Intent* carg1, int carg2, inworld_Intent* carg3);

SWIGIMPORT void inworld_vector_Intent_delete(inworld_vector_Intent* carg1);

SWIGIMPORT inworld_vector_IntentMatch* inworld_vector_IntentMatch_new();

SWIGIMPORT inworld_vector_IntentMatch* inworld_vector_IntentMatch_copy(inworld_vector_IntentMatch* carg1);

SWIGIMPORT size_t inworld_vector_IntentMatch_size(inworld_vector_IntentMatch* carg1);

SWIGIMPORT size_t inworld_vector_IntentMatch_capacity(inworld_vector_IntentMatch* carg1);

SWIGIMPORT void inworld_vector_IntentMatch_reserve(inworld_vector_IntentMatch* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_IntentMatch_empty(inworld_vector_IntentMatch* carg1);

SWIGIMPORT void inworld_vector_IntentMatch_clear(inworld_vector_IntentMatch* carg1);

SWIGIMPORT void inworld_vector_IntentMatch_push_back(inworld_vector_IntentMatch* carg1, inworld_IntentMatch* carg2);

SWIGIMPORT inworld_IntentMatch* inworld_vector_IntentMatch_get(inworld_vector_IntentMatch* carg1, int carg2);

SWIGIMPORT void inworld_vector_IntentMatch_set(inworld_vector_IntentMatch* carg1, int carg2, inworld_IntentMatch* carg3);

SWIGIMPORT void inworld_vector_IntentMatch_delete(inworld_vector_IntentMatch* carg1);

SWIGIMPORT inworld_vector_KeywordMatch* inworld_vector_KeywordMatch_new();

SWIGIMPORT inworld_vector_KeywordMatch* inworld_vector_KeywordMatch_copy(inworld_vector_KeywordMatch* carg1);

SWIGIMPORT size_t inworld_vector_KeywordMatch_size(inworld_vector_KeywordMatch* carg1);

SWIGIMPORT size_t inworld_vector_KeywordMatch_capacity(inworld_vector_KeywordMatch* carg1);

SWIGIMPORT void inworld_vector_KeywordMatch_reserve(inworld_vector_KeywordMatch* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_KeywordMatch_empty(inworld_vector_KeywordMatch* carg1);

SWIGIMPORT void inworld_vector_KeywordMatch_clear(inworld_vector_KeywordMatch* carg1);

SWIGIMPORT void inworld_vector_KeywordMatch_push_back(inworld_vector_KeywordMatch* carg1, inworld_KeywordMatch* carg2);

SWIGIMPORT inworld_KeywordMatch* inworld_vector_KeywordMatch_get(inworld_vector_KeywordMatch* carg1, int carg2);

SWIGIMPORT void inworld_vector_KeywordMatch_set(inworld_vector_KeywordMatch* carg1, int carg2, inworld_KeywordMatch* carg3);

SWIGIMPORT void inworld_vector_KeywordMatch_delete(inworld_vector_KeywordMatch* carg1);

SWIGIMPORT inworld_vector_KeywordGroup* inworld_vector_KeywordGroup_new();

SWIGIMPORT inworld_vector_KeywordGroup* inworld_vector_KeywordGroup_copy(inworld_vector_KeywordGroup* carg1);

SWIGIMPORT size_t inworld_vector_KeywordGroup_size(inworld_vector_KeywordGroup* carg1);

SWIGIMPORT size_t inworld_vector_KeywordGroup_capacity(inworld_vector_KeywordGroup* carg1);

SWIGIMPORT void inworld_vector_KeywordGroup_reserve(inworld_vector_KeywordGroup* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_KeywordGroup_empty(inworld_vector_KeywordGroup* carg1);

SWIGIMPORT void inworld_vector_KeywordGroup_clear(inworld_vector_KeywordGroup* carg1);

SWIGIMPORT void inworld_vector_KeywordGroup_push_back(inworld_vector_KeywordGroup* carg1, inworld_KeywordGroup* carg2);

SWIGIMPORT inworld_KeywordGroup* inworld_vector_KeywordGroup_get(inworld_vector_KeywordGroup* carg1, int carg2);

SWIGIMPORT void inworld_vector_KeywordGroup_set(inworld_vector_KeywordGroup* carg1, int carg2, inworld_KeywordGroup* carg3);

SWIGIMPORT void inworld_vector_KeywordGroup_delete(inworld_vector_KeywordGroup* carg1);

SWIGIMPORT inworld_vector_PhraseMatch* inworld_vector_PhraseMatch_new();

SWIGIMPORT inworld_vector_PhraseMatch* inworld_vector_PhraseMatch_copy(inworld_vector_PhraseMatch* carg1);

SWIGIMPORT size_t inworld_vector_PhraseMatch_size(inworld_vector_PhraseMatch* carg1);

SWIGIMPORT size_t inworld_vector_PhraseMatch_capacity(inworld_vector_PhraseMatch* carg1);

SWIGIMPORT void inworld_vector_PhraseMatch_reserve(inworld_vector_PhraseMatch* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_PhraseMatch_empty(inworld_vector_PhraseMatch* carg1);

SWIGIMPORT void inworld_vector_PhraseMatch_clear(inworld_vector_PhraseMatch* carg1);

SWIGIMPORT void inworld_vector_PhraseMatch_push_back(inworld_vector_PhraseMatch* carg1, inworld_PhraseMatch* carg2);

SWIGIMPORT inworld_PhraseMatch* inworld_vector_PhraseMatch_get(inworld_vector_PhraseMatch* carg1, int carg2);

SWIGIMPORT void inworld_vector_PhraseMatch_set(inworld_vector_PhraseMatch* carg1, int carg2, inworld_PhraseMatch* carg3);

SWIGIMPORT void inworld_vector_PhraseMatch_delete(inworld_vector_PhraseMatch* carg1);

SWIGIMPORT inworld_vector_KnowledgeRecord* inworld_vector_KnowledgeRecord_new();

SWIGIMPORT inworld_vector_KnowledgeRecord* inworld_vector_KnowledgeRecord_copy(inworld_vector_KnowledgeRecord* carg1);

SWIGIMPORT size_t inworld_vector_KnowledgeRecord_size(inworld_vector_KnowledgeRecord* carg1);

SWIGIMPORT size_t inworld_vector_KnowledgeRecord_capacity(inworld_vector_KnowledgeRecord* carg1);

SWIGIMPORT void inworld_vector_KnowledgeRecord_reserve(inworld_vector_KnowledgeRecord* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_KnowledgeRecord_empty(inworld_vector_KnowledgeRecord* carg1);

SWIGIMPORT void inworld_vector_KnowledgeRecord_clear(inworld_vector_KnowledgeRecord* carg1);

SWIGIMPORT void inworld_vector_KnowledgeRecord_push_back(inworld_vector_KnowledgeRecord* carg1, inworld_KnowledgeRecord* carg2);

SWIGIMPORT inworld_KnowledgeRecord* inworld_vector_KnowledgeRecord_get(inworld_vector_KnowledgeRecord* carg1, int carg2);

SWIGIMPORT void inworld_vector_KnowledgeRecord_set(inworld_vector_KnowledgeRecord* carg1, int carg2, inworld_KnowledgeRecord* carg3);

SWIGIMPORT void inworld_vector_KnowledgeRecord_delete(inworld_vector_KnowledgeRecord* carg1);

SWIGIMPORT inworld_vector_KnowledgeCollection* inworld_vector_KnowledgeCollection_new();

SWIGIMPORT inworld_vector_KnowledgeCollection* inworld_vector_KnowledgeCollection_copy(inworld_vector_KnowledgeCollection* carg1);

SWIGIMPORT size_t inworld_vector_KnowledgeCollection_size(inworld_vector_KnowledgeCollection* carg1);

SWIGIMPORT size_t inworld_vector_KnowledgeCollection_capacity(inworld_vector_KnowledgeCollection* carg1);

SWIGIMPORT void inworld_vector_KnowledgeCollection_reserve(inworld_vector_KnowledgeCollection* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_KnowledgeCollection_empty(inworld_vector_KnowledgeCollection* carg1);

SWIGIMPORT void inworld_vector_KnowledgeCollection_clear(inworld_vector_KnowledgeCollection* carg1);

SWIGIMPORT void inworld_vector_KnowledgeCollection_push_back(inworld_vector_KnowledgeCollection* carg1, inworld_KnowledgeCollection* carg2);

SWIGIMPORT inworld_KnowledgeCollection* inworld_vector_KnowledgeCollection_get(inworld_vector_KnowledgeCollection* carg1, int carg2);

SWIGIMPORT void inworld_vector_KnowledgeCollection_set(inworld_vector_KnowledgeCollection* carg1, int carg2, inworld_KnowledgeCollection* carg3);

SWIGIMPORT void inworld_vector_KnowledgeCollection_delete(inworld_vector_KnowledgeCollection* carg1);

SWIGIMPORT inworld_vector_LLMRoutingConfig* inworld_vector_LLMRoutingConfig_new();

SWIGIMPORT inworld_vector_LLMRoutingConfig* inworld_vector_LLMRoutingConfig_copy(inworld_vector_LLMRoutingConfig* carg1);

SWIGIMPORT size_t inworld_vector_LLMRoutingConfig_size(inworld_vector_LLMRoutingConfig* carg1);

SWIGIMPORT size_t inworld_vector_LLMRoutingConfig_capacity(inworld_vector_LLMRoutingConfig* carg1);

SWIGIMPORT void inworld_vector_LLMRoutingConfig_reserve(inworld_vector_LLMRoutingConfig* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_LLMRoutingConfig_empty(inworld_vector_LLMRoutingConfig* carg1);

SWIGIMPORT void inworld_vector_LLMRoutingConfig_clear(inworld_vector_LLMRoutingConfig* carg1);

SWIGIMPORT void inworld_vector_LLMRoutingConfig_push_back(inworld_vector_LLMRoutingConfig* carg1, inworld_LLMRoutingConfig* carg2);

SWIGIMPORT inworld_LLMRoutingConfig* inworld_vector_LLMRoutingConfig_get(inworld_vector_LLMRoutingConfig* carg1, int carg2);

SWIGIMPORT void inworld_vector_LLMRoutingConfig_set(inworld_vector_LLMRoutingConfig* carg1, int carg2, inworld_LLMRoutingConfig* carg3);

SWIGIMPORT void inworld_vector_LLMRoutingConfig_delete(inworld_vector_LLMRoutingConfig* carg1);

SWIGIMPORT inworld_vector_TopicThreshold* inworld_vector_TopicThreshold_new();

SWIGIMPORT inworld_vector_TopicThreshold* inworld_vector_TopicThreshold_copy(inworld_vector_TopicThreshold* carg1);

SWIGIMPORT size_t inworld_vector_TopicThreshold_size(inworld_vector_TopicThreshold* carg1);

SWIGIMPORT size_t inworld_vector_TopicThreshold_capacity(inworld_vector_TopicThreshold* carg1);

SWIGIMPORT void inworld_vector_TopicThreshold_reserve(inworld_vector_TopicThreshold* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_TopicThreshold_empty(inworld_vector_TopicThreshold* carg1);

SWIGIMPORT void inworld_vector_TopicThreshold_clear(inworld_vector_TopicThreshold* carg1);

SWIGIMPORT void inworld_vector_TopicThreshold_push_back(inworld_vector_TopicThreshold* carg1, inworld_TopicThreshold* carg2);

SWIGIMPORT inworld_TopicThreshold* inworld_vector_TopicThreshold_get(inworld_vector_TopicThreshold* carg1, int carg2);

SWIGIMPORT void inworld_vector_TopicThreshold_set(inworld_vector_TopicThreshold* carg1, int carg2, inworld_TopicThreshold* carg3);

SWIGIMPORT void inworld_vector_TopicThreshold_delete(inworld_vector_TopicThreshold* carg1);

SWIGIMPORT inworld_vector_DetectedTopic* inworld_vector_DetectedTopic_new();

SWIGIMPORT inworld_vector_DetectedTopic* inworld_vector_DetectedTopic_copy(inworld_vector_DetectedTopic* carg1);

SWIGIMPORT size_t inworld_vector_DetectedTopic_size(inworld_vector_DetectedTopic* carg1);

SWIGIMPORT size_t inworld_vector_DetectedTopic_capacity(inworld_vector_DetectedTopic* carg1);

SWIGIMPORT void inworld_vector_DetectedTopic_reserve(inworld_vector_DetectedTopic* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_DetectedTopic_empty(inworld_vector_DetectedTopic* carg1);

SWIGIMPORT void inworld_vector_DetectedTopic_clear(inworld_vector_DetectedTopic* carg1);

SWIGIMPORT void inworld_vector_DetectedTopic_push_back(inworld_vector_DetectedTopic* carg1, inworld_DetectedTopic* carg2);

SWIGIMPORT inworld_DetectedTopic* inworld_vector_DetectedTopic_get(inworld_vector_DetectedTopic* carg1, int carg2);

SWIGIMPORT void inworld_vector_DetectedTopic_set(inworld_vector_DetectedTopic* carg1, int carg2, inworld_DetectedTopic* carg3);

SWIGIMPORT void inworld_vector_DetectedTopic_delete(inworld_vector_DetectedTopic* carg1);

SWIGIMPORT inworld_vector_DictionaryRule* inworld_vector_DictionaryRule_new();

SWIGIMPORT inworld_vector_DictionaryRule* inworld_vector_DictionaryRule_copy(inworld_vector_DictionaryRule* carg1);

SWIGIMPORT size_t inworld_vector_DictionaryRule_size(inworld_vector_DictionaryRule* carg1);

SWIGIMPORT size_t inworld_vector_DictionaryRule_capacity(inworld_vector_DictionaryRule* carg1);

SWIGIMPORT void inworld_vector_DictionaryRule_reserve(inworld_vector_DictionaryRule* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_DictionaryRule_empty(inworld_vector_DictionaryRule* carg1);

SWIGIMPORT void inworld_vector_DictionaryRule_clear(inworld_vector_DictionaryRule* carg1);

SWIGIMPORT void inworld_vector_DictionaryRule_push_back(inworld_vector_DictionaryRule* carg1, inworld_DictionaryRule* carg2);

SWIGIMPORT inworld_DictionaryRule* inworld_vector_DictionaryRule_get(inworld_vector_DictionaryRule* carg1, int carg2);

SWIGIMPORT void inworld_vector_DictionaryRule_set(inworld_vector_DictionaryRule* carg1, int carg2, inworld_DictionaryRule* carg3);

SWIGIMPORT void inworld_vector_DictionaryRule_delete(inworld_vector_DictionaryRule* carg1);

SWIGIMPORT inworld_vector_Entity* inworld_vector_Entity_new();

SWIGIMPORT inworld_vector_Entity* inworld_vector_Entity_copy(inworld_vector_Entity* carg1);

SWIGIMPORT size_t inworld_vector_Entity_size(inworld_vector_Entity* carg1);

SWIGIMPORT size_t inworld_vector_Entity_capacity(inworld_vector_Entity* carg1);

SWIGIMPORT void inworld_vector_Entity_reserve(inworld_vector_Entity* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_Entity_empty(inworld_vector_Entity* carg1);

SWIGIMPORT void inworld_vector_Entity_clear(inworld_vector_Entity* carg1);

SWIGIMPORT void inworld_vector_Entity_push_back(inworld_vector_Entity* carg1, inworld_Entity* carg2);

SWIGIMPORT inworld_Entity* inworld_vector_Entity_get(inworld_vector_Entity* carg1, int carg2);

SWIGIMPORT void inworld_vector_Entity_set(inworld_vector_Entity* carg1, int carg2, inworld_Entity* carg3);

SWIGIMPORT void inworld_vector_Entity_delete(inworld_vector_Entity* carg1);

SWIGIMPORT inworld_vector_EntityMatch* inworld_vector_EntityMatch_new();

SWIGIMPORT inworld_vector_EntityMatch* inworld_vector_EntityMatch_copy(inworld_vector_EntityMatch* carg1);

SWIGIMPORT size_t inworld_vector_EntityMatch_size(inworld_vector_EntityMatch* carg1);

SWIGIMPORT size_t inworld_vector_EntityMatch_capacity(inworld_vector_EntityMatch* carg1);

SWIGIMPORT void inworld_vector_EntityMatch_reserve(inworld_vector_EntityMatch* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_EntityMatch_empty(inworld_vector_EntityMatch* carg1);

SWIGIMPORT void inworld_vector_EntityMatch_clear(inworld_vector_EntityMatch* carg1);

SWIGIMPORT void inworld_vector_EntityMatch_push_back(inworld_vector_EntityMatch* carg1, inworld_EntityMatch* carg2);

SWIGIMPORT inworld_EntityMatch* inworld_vector_EntityMatch_get(inworld_vector_EntityMatch* carg1, int carg2);

SWIGIMPORT void inworld_vector_EntityMatch_set(inworld_vector_EntityMatch* carg1, int carg2, inworld_EntityMatch* carg3);

SWIGIMPORT void inworld_vector_EntityMatch_delete(inworld_vector_EntityMatch* carg1);

SWIGIMPORT inworld_vector_vector_float* inworld_vector_vector_float_new();

SWIGIMPORT inworld_vector_vector_float* inworld_vector_vector_float_copy(inworld_vector_vector_float* carg1);

SWIGIMPORT size_t inworld_vector_vector_float_size(inworld_vector_vector_float* carg1);

SWIGIMPORT size_t inworld_vector_vector_float_capacity(inworld_vector_vector_float* carg1);

SWIGIMPORT void inworld_vector_vector_float_reserve(inworld_vector_vector_float* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_vector_float_empty(inworld_vector_vector_float* carg1);

SWIGIMPORT void inworld_vector_vector_float_clear(inworld_vector_vector_float* carg1);

SWIGIMPORT void inworld_vector_vector_float_push_back(inworld_vector_vector_float* carg1, inworld_vector_float* carg2);

SWIGIMPORT inworld_vector_float* inworld_vector_vector_float_get(inworld_vector_vector_float* carg1, int carg2);

SWIGIMPORT void inworld_vector_vector_float_set(inworld_vector_vector_float* carg1, int carg2, inworld_vector_float* carg3);

SWIGIMPORT void inworld_vector_vector_float_delete(inworld_vector_vector_float* carg1);

SWIGIMPORT inworld_vector_string* inworld_vector_string_new();

SWIGIMPORT inworld_vector_string* inworld_vector_string_copy(inworld_vector_string* carg1);

SWIGIMPORT size_t inworld_vector_string_size(inworld_vector_string* carg1);

SWIGIMPORT size_t inworld_vector_string_capacity(inworld_vector_string* carg1);

SWIGIMPORT void inworld_vector_string_reserve(inworld_vector_string* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_string_empty(inworld_vector_string* carg1);

SWIGIMPORT void inworld_vector_string_clear(inworld_vector_string* carg1);

SWIGIMPORT void inworld_vector_string_push_back(inworld_vector_string* carg1, const char * carg2);

SWIGIMPORT const char * inworld_vector_string_get(inworld_vector_string* carg1, int carg2);

SWIGIMPORT void inworld_vector_string_set(inworld_vector_string* carg1, int carg2, const char * carg3);

SWIGIMPORT void inworld_vector_string_delete(inworld_vector_string* carg1);

SWIGIMPORT inworld_vector_map_string_string* inworld_vector_map_string_string_new();

SWIGIMPORT inworld_vector_map_string_string* inworld_vector_map_string_string_copy(inworld_vector_map_string_string* carg1);

SWIGIMPORT size_t inworld_vector_map_string_string_size(inworld_vector_map_string_string* carg1);

SWIGIMPORT size_t inworld_vector_map_string_string_capacity(inworld_vector_map_string_string* carg1);

SWIGIMPORT void inworld_vector_map_string_string_reserve(inworld_vector_map_string_string* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_map_string_string_empty(inworld_vector_map_string_string* carg1);

SWIGIMPORT void inworld_vector_map_string_string_clear(inworld_vector_map_string_string* carg1);

SWIGIMPORT void inworld_vector_map_string_string_push_back(inworld_vector_map_string_string* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_vector_map_string_string_get(inworld_vector_map_string_string* carg1, int carg2);

SWIGIMPORT void inworld_vector_map_string_string_set(inworld_vector_map_string_string* carg1, int carg2, inworld_map_string_string* carg3);

SWIGIMPORT void inworld_vector_map_string_string_delete(inworld_vector_map_string_string* carg1);

SWIGIMPORT inworld_map_string_string* inworld_map_string_string_new();

SWIGIMPORT inworld_map_string_string* inworld_map_string_string_copy(inworld_map_string_string* carg1);

SWIGIMPORT size_t inworld_map_string_string_size(inworld_map_string_string* carg1);

SWIGIMPORT bool inworld_map_string_string_empty(inworld_map_string_string* carg1);

SWIGIMPORT void inworld_map_string_string_clear(inworld_map_string_string* carg1);

SWIGIMPORT const char * inworld_map_string_string_get(inworld_map_string_string* carg1, const char * carg2);

SWIGIMPORT void inworld_map_string_string_set(inworld_map_string_string* carg1, const char * carg2, const char * carg3);

SWIGIMPORT void inworld_map_string_string_del(inworld_map_string_string* carg1, const char * carg2);

SWIGIMPORT bool inworld_map_string_string_has_key(inworld_map_string_string* carg1, const char * carg2);

SWIGIMPORT void inworld_map_string_string_delete(inworld_map_string_string* carg1);

SWIGIMPORT inworld_optional_BatchProcessingOptions* inworld_optional_BatchProcessingOptions_new();

SWIGIMPORT inworld_optional_BatchProcessingOptions* inworld_optional_BatchProcessingOptions_new_rcinworld_BatchProcessingOptions(inworld_BatchProcessingOptions* carg1);

SWIGIMPORT inworld_optional_BatchProcessingOptions* inworld_optional_BatchProcessingOptions_copy(inworld_optional_BatchProcessingOptions* carg1);

SWIGIMPORT void inworld_optional_BatchProcessingOptions_delete(inworld_optional_BatchProcessingOptions* carg1);

SWIGIMPORT bool inworld_optional_BatchProcessingOptions_has_value(inworld_optional_BatchProcessingOptions* carg1);

SWIGIMPORT inworld_BatchProcessingOptions* inworld_optional_BatchProcessingOptions_value(inworld_optional_BatchProcessingOptions* carg1);

SWIGIMPORT inworld_BatchProcessingOptions* inworld_optional_BatchProcessingOptions_valueConst(inworld_optional_BatchProcessingOptions* carg1);

SWIGIMPORT inworld_BatchProcessingOptions* inworld_optional_BatchProcessingOptions_value_or(inworld_optional_BatchProcessingOptions* carg1, inworld_BatchProcessingOptions* carg2);

SWIGIMPORT void inworld_optional_BatchProcessingOptions_reset(inworld_optional_BatchProcessingOptions* carg1);

SWIGIMPORT inworld_BatchProcessingOptions* inworld_optional_BatchProcessingOptions_get(inworld_optional_BatchProcessingOptions* carg1);

SWIGIMPORT inworld_BatchProcessingOptions* inworld_optional_BatchProcessingOptions_getConst(inworld_optional_BatchProcessingOptions* carg1);

SWIGIMPORT inworld_BatchProcessingOptions* inworld_optional_BatchProcessingOptions_get_value(inworld_optional_BatchProcessingOptions* carg1);

SWIGIMPORT void inworld_optional_BatchProcessingOptions_set_value(inworld_optional_BatchProcessingOptions* carg1, inworld_BatchProcessingOptions* carg2);

SWIGIMPORT void inworld_Span_SetAttribute_rcstd_string_rcstd_string(inworld_Span* carg1, const char * carg2, const char * carg3);

SWIGIMPORT void inworld_Span_SetAttribute_rcstd_string_rcstd_vector_Sl_std_string_Sg_(inworld_Span* carg1, const char * carg2, inworld_vector_string* carg3);

SWIGIMPORT void inworld_Span_SetOK(inworld_Span* carg1);

SWIGIMPORT void inworld_Span_SetError(inworld_Span* carg1, const char * carg2);

SWIGIMPORT void inworld_Span_End(inworld_Span* carg1);

SWIGIMPORT void inworld_Span_delete(inworld_Span* carg1);

SWIGIMPORT void inworld_SpanDataEvent_name_set(inworld_SpanDataEvent* carg1, const char * carg2);

SWIGIMPORT const char * inworld_SpanDataEvent_name_get(inworld_SpanDataEvent* carg1);

SWIGIMPORT void inworld_SpanDataEvent_timestampInNanos_set(inworld_SpanDataEvent* carg1, long long carg2);

SWIGIMPORT long long inworld_SpanDataEvent_timestampInNanos_get(inworld_SpanDataEvent* carg1);

SWIGIMPORT void inworld_SpanDataEvent_attributes_set(inworld_SpanDataEvent* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_SpanDataEvent_attributes_get(inworld_SpanDataEvent* carg1);

SWIGIMPORT inworld_SpanDataEvent* inworld_SpanDataEvent_new();

SWIGIMPORT inworld_SpanDataEvent* inworld_SpanDataEvent_copy(inworld_SpanDataEvent* carg1);

SWIGIMPORT void inworld_SpanDataEvent_delete(inworld_SpanDataEvent* carg1);

SWIGIMPORT const char * inworld_SpanData_GetTraceId(inworld_SpanData* carg1);

SWIGIMPORT const char * inworld_SpanData_GetSpanId(inworld_SpanData* carg1);

SWIGIMPORT const char * inworld_SpanData_GetParentSpanId(inworld_SpanData* carg1);

SWIGIMPORT const char * inworld_SpanData_GetName(inworld_SpanData* carg1);

SWIGIMPORT const char * inworld_SpanData_GetDescription(inworld_SpanData* carg1);

SWIGIMPORT long long inworld_SpanData_GetStartTimeInNanos(inworld_SpanData* carg1);

SWIGIMPORT long long inworld_SpanData_GetDurationInNanos(inworld_SpanData* carg1);

SWIGIMPORT const char * inworld_SpanData_GetSpanKind(inworld_SpanData* carg1);

SWIGIMPORT const char * inworld_SpanData_GetStatus(inworld_SpanData* carg1);

SWIGIMPORT inworld_map_string_string* inworld_SpanData_GetAttributes(inworld_SpanData* carg1);

SWIGIMPORT inworld_vector_SpanDataEvent* inworld_SpanData_GetEvents(inworld_SpanData* carg1);

SWIGIMPORT void inworld_SpanData_delete(inworld_SpanData* carg1);

SWIGIMPORT const char * inworld_GenerateExecutionId();

SWIGIMPORT inworld_Span* inworld_StartSpan_rcstd_string(const char * carg1);

SWIGIMPORT inworld_Span* inworld_StartSpan_rcstd_string_rcstd_map_Sl_std_string_Sc_std_string_Sg_(const char * carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_Span* inworld_StartSpan_rcstd_string_rstd_map_Sl_std_string_Sc_std_string_Sg__rcstd_vector_Sl_inworld_telemetry_Span_Sg__rcinworld_telemetry_Span(const char * carg1, inworld_map_string_string* carg2, inworld_vector_TelemetrySpan* carg3, inworld_Span* carg4);

SWIGIMPORT inworld_vector_SpanData* inworld_DequeueSpanTraces(size_t carg1);

SWIGIMPORT char * inworld_kTelemetryApiKey_get();

SWIGIMPORT char * inworld_kTelemetryEndpoint_get();

SWIGIMPORT char * inworld_kTelemetryDontGreet_get();

SWIGIMPORT void inworld_BatchProcessingOptions_max_queue_size_set(inworld_BatchProcessingOptions* carg1, size_t carg2);

SWIGIMPORT size_t inworld_BatchProcessingOptions_max_queue_size_get(inworld_BatchProcessingOptions* carg1);

SWIGIMPORT void inworld_BatchProcessingOptions_max_export_batch_size_set(inworld_BatchProcessingOptions* carg1, size_t carg2);

SWIGIMPORT size_t inworld_BatchProcessingOptions_max_export_batch_size_get(inworld_BatchProcessingOptions* carg1);

SWIGIMPORT inworld_BatchProcessingOptions* inworld_BatchProcessingOptions_new();

SWIGIMPORT inworld_BatchProcessingOptions* inworld_BatchProcessingOptions_copy(inworld_BatchProcessingOptions* carg1);

SWIGIMPORT void inworld_BatchProcessingOptions_delete(inworld_BatchProcessingOptions* carg1);

SWIGIMPORT void inworld_TracerConfig_sampling_rate_set(inworld_TracerConfig* carg1, double carg2);

SWIGIMPORT double inworld_TracerConfig_sampling_rate_get(inworld_TracerConfig* carg1);

SWIGIMPORT void inworld_TracerConfig_span_dump_path_set(inworld_TracerConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TracerConfig_span_dump_path_get(inworld_TracerConfig* carg1);

SWIGIMPORT void inworld_TracerConfig_batch_processing_opts_set(inworld_TracerConfig* carg1, inworld_optional_BatchProcessingOptions* carg2);

SWIGIMPORT inworld_optional_BatchProcessingOptions* inworld_TracerConfig_batch_processing_opts_get(inworld_TracerConfig* carg1);

SWIGIMPORT void inworld_TracerConfig_enable_span_capture_set(inworld_TracerConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_TracerConfig_enable_span_capture_get(inworld_TracerConfig* carg1);

SWIGIMPORT void inworld_TracerConfig_max_queue_size_set(inworld_TracerConfig* carg1, size_t carg2);

SWIGIMPORT size_t inworld_TracerConfig_max_queue_size_get(inworld_TracerConfig* carg1);

SWIGIMPORT inworld_TracerConfig* inworld_TracerConfig_new();

SWIGIMPORT inworld_TracerConfig* inworld_TracerConfig_copy(inworld_TracerConfig* carg1);

SWIGIMPORT void inworld_TracerConfig_delete(inworld_TracerConfig* carg1);

SWIGIMPORT void inworld_LoggerConfig_log_level_set(inworld_LoggerConfig* carg1, enum inworld_LogLevel carg2);

SWIGIMPORT enum inworld_LogLevel inworld_LoggerConfig_log_level_get(inworld_LoggerConfig* carg1);

SWIGIMPORT void inworld_LoggerConfig_sink_absl_logs_set(inworld_LoggerConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_LoggerConfig_sink_absl_logs_get(inworld_LoggerConfig* carg1);

SWIGIMPORT void inworld_LoggerConfig_batch_processing_opts_set(inworld_LoggerConfig* carg1, inworld_optional_BatchProcessingOptions* carg2);

SWIGIMPORT inworld_optional_BatchProcessingOptions* inworld_LoggerConfig_batch_processing_opts_get(inworld_LoggerConfig* carg1);

SWIGIMPORT inworld_LoggerConfig* inworld_LoggerConfig_new();

SWIGIMPORT inworld_LoggerConfig* inworld_LoggerConfig_copy(inworld_LoggerConfig* carg1);

SWIGIMPORT void inworld_LoggerConfig_delete(inworld_LoggerConfig* carg1);

SWIGIMPORT void inworld_MetricConfig_metric_type_set(inworld_MetricConfig* carg1, enum inworld_MetricConfig_MetricType carg2);

SWIGIMPORT enum inworld_MetricConfig_MetricType inworld_MetricConfig_metric_type_get(inworld_MetricConfig* carg1);

SWIGIMPORT void inworld_MetricConfig_name_set(inworld_MetricConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MetricConfig_name_get(inworld_MetricConfig* carg1);

SWIGIMPORT void inworld_MetricConfig_description_set(inworld_MetricConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MetricConfig_description_get(inworld_MetricConfig* carg1);

SWIGIMPORT void inworld_MetricConfig_unit_set(inworld_MetricConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MetricConfig_unit_get(inworld_MetricConfig* carg1);

SWIGIMPORT inworld_MetricConfig* inworld_MetricConfig_new();

SWIGIMPORT inworld_MetricConfig* inworld_MetricConfig_copy(inworld_MetricConfig* carg1);

SWIGIMPORT void inworld_MetricConfig_delete(inworld_MetricConfig* carg1);

SWIGIMPORT void inworld_TelemetryConfig_tracer_set(inworld_TelemetryConfig* carg1, inworld_TracerConfig* carg2);

SWIGIMPORT inworld_TracerConfig* inworld_TelemetryConfig_tracer_get(inworld_TelemetryConfig* carg1);

SWIGIMPORT void inworld_TelemetryConfig_logger_set(inworld_TelemetryConfig* carg1, inworld_LoggerConfig* carg2);

SWIGIMPORT inworld_LoggerConfig* inworld_TelemetryConfig_logger_get(inworld_TelemetryConfig* carg1);

SWIGIMPORT void inworld_TelemetryConfig_service_name_set(inworld_TelemetryConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TelemetryConfig_service_name_get(inworld_TelemetryConfig* carg1);

SWIGIMPORT void inworld_TelemetryConfig_service_version_set(inworld_TelemetryConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TelemetryConfig_service_version_get(inworld_TelemetryConfig* carg1);

SWIGIMPORT void inworld_TelemetryConfig_endpoint_set(inworld_TelemetryConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TelemetryConfig_endpoint_get(inworld_TelemetryConfig* carg1);

SWIGIMPORT void inworld_TelemetryConfig_api_key_set(inworld_TelemetryConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TelemetryConfig_api_key_get(inworld_TelemetryConfig* carg1);

SWIGIMPORT void inworld_TelemetryConfig_exporter_type_set(inworld_TelemetryConfig* carg1, enum inworld_ExporterType carg2);

SWIGIMPORT enum inworld_ExporterType inworld_TelemetryConfig_exporter_type_get(inworld_TelemetryConfig* carg1);

SWIGIMPORT void inworld_TelemetryConfig_sdk_name_set(inworld_TelemetryConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TelemetryConfig_sdk_name_get(inworld_TelemetryConfig* carg1);

SWIGIMPORT void inworld_TelemetryConfig_sdk_version_set(inworld_TelemetryConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TelemetryConfig_sdk_version_get(inworld_TelemetryConfig* carg1);

SWIGIMPORT inworld_TelemetryConfig* inworld_TelemetryConfig_new();

SWIGIMPORT inworld_TelemetryConfig* inworld_TelemetryConfig_copy(inworld_TelemetryConfig* carg1);

SWIGIMPORT void inworld_TelemetryConfig_delete(inworld_TelemetryConfig* carg1);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_new();

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetServiceName(inworld_TelemetryConfigBuilder* carg1, const char * carg2);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetServiceVersion(inworld_TelemetryConfigBuilder* carg1, const char * carg2);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetExporterType(inworld_TelemetryConfigBuilder* carg1, enum inworld_ExporterType carg2);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetSdkName(inworld_TelemetryConfigBuilder* carg1, const char * carg2);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetSdkVersion(inworld_TelemetryConfigBuilder* carg1, const char * carg2);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetEndpoint(inworld_TelemetryConfigBuilder* carg1, const char * carg2);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetApiKey(inworld_TelemetryConfigBuilder* carg1, const char * carg2);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetSinkAbslLogs(inworld_TelemetryConfigBuilder* carg1, bool carg2);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetSamplingRate(inworld_TelemetryConfigBuilder* carg1, double carg2);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetLogLevel(inworld_TelemetryConfigBuilder* carg1, enum inworld_LogLevel carg2);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_SetSpanDumpPath(inworld_TelemetryConfigBuilder* carg1, const char * carg2);

SWIGIMPORT inworld_TelemetryConfig* inworld_TelemetryConfigBuilder_Build(inworld_TelemetryConfigBuilder* carg1);

SWIGIMPORT inworld_TelemetryConfigBuilder* inworld_TelemetryConfigBuilder_copy(inworld_TelemetryConfigBuilder* carg1);

SWIGIMPORT void inworld_TelemetryConfigBuilder_delete(inworld_TelemetryConfigBuilder* carg1);

SWIGIMPORT void inworld_ConfigureTelemetry_rcinworld_TelemetryConfig(inworld_TelemetryConfig* carg1);

SWIGIMPORT void inworld_ConfigureTelemetry_rcstd_string_rcstd_string(const char * carg1, const char * carg2);

SWIGIMPORT void inworld_ShutdownTelemetry();

SWIGIMPORT void inworld_ConfigureMetric(inworld_MetricConfig* carg1);

SWIGIMPORT void inworld_RecordCounterUInt_rcstd_string_unsigned_SS_long_SS_long_rcstd_map_Sl_std_string_Sc_std_string_Sg_(const char * carg1, unsigned long long carg2, inworld_map_string_string* carg3);

SWIGIMPORT void inworld_RecordCounterUInt_rcstd_string_unsigned_SS_long_SS_long(const char * carg1, unsigned long long carg2);

SWIGIMPORT void inworld_RecordCounterDouble_rcstd_string_d_rcstd_map_Sl_std_string_Sc_std_string_Sg_(const char * carg1, double carg2, inworld_map_string_string* carg3);

SWIGIMPORT void inworld_RecordCounterDouble_rcstd_string_d(const char * carg1, double carg2);

SWIGIMPORT void inworld_RecordGaugeInt_rcstd_string_long_SS_long_rcstd_map_Sl_std_string_Sc_std_string_Sg_(const char * carg1, long long carg2, inworld_map_string_string* carg3);

SWIGIMPORT void inworld_RecordGaugeInt_rcstd_string_long_SS_long(const char * carg1, long long carg2);

SWIGIMPORT void inworld_RecordGaugeDouble_rcstd_string_d_rcstd_map_Sl_std_string_Sc_std_string_Sg_(const char * carg1, double carg2, inworld_map_string_string* carg3);

SWIGIMPORT void inworld_RecordGaugeDouble_rcstd_string_d(const char * carg1, double carg2);

SWIGIMPORT void inworld_RecordHistogramUInt_rcstd_string_unsigned_SS_long_SS_long_rcstd_map_Sl_std_string_Sc_std_string_Sg_(const char * carg1, unsigned long long carg2, inworld_map_string_string* carg3);

SWIGIMPORT void inworld_RecordHistogramUInt_rcstd_string_unsigned_SS_long_SS_long(const char * carg1, unsigned long long carg2);

SWIGIMPORT void inworld_RecordHistogramDouble_rcstd_string_d_rcstd_map_Sl_std_string_Sc_std_string_Sg_(const char * carg1, double carg2, inworld_map_string_string* carg3);

SWIGIMPORT void inworld_RecordHistogramDouble_rcstd_string_d(const char * carg1, double carg2);

SWIGIMPORT void inworld_LogMessage_eLogLevel_rcstd_string_rcstd_map_Sl_std_string_Sc_std_string_Sg_(enum inworld_LogLevel carg1, const char * carg2, inworld_map_string_string* carg3);

SWIGIMPORT void inworld_LogMessage_eLogLevel_rcstd_string(enum inworld_LogLevel carg1, const char * carg2);

SWIGIMPORT void inworld_LogMessage_eLogLevel_rcstd_string_rcinworld_graphs_ProcessContext_rcstd_map_Sl_std_string_Sc_std_string_Sg_(enum inworld_LogLevel carg1, const char * carg2, inworld_ProcessContext* carg3, inworld_map_string_string* carg4);

SWIGIMPORT void inworld_LogMessage_eLogLevel_rcstd_string_rcinworld_graphs_ProcessContext(enum inworld_LogLevel carg1, const char * carg2, inworld_ProcessContext* carg3);

SWIGIMPORT inworld_vector_TelemetrySpan* inworld_vector_TelemetrySpan_new();

SWIGIMPORT inworld_vector_TelemetrySpan* inworld_vector_TelemetrySpan_copy(inworld_vector_TelemetrySpan* carg1);

SWIGIMPORT size_t inworld_vector_TelemetrySpan_size(inworld_vector_TelemetrySpan* carg1);

SWIGIMPORT size_t inworld_vector_TelemetrySpan_capacity(inworld_vector_TelemetrySpan* carg1);

SWIGIMPORT void inworld_vector_TelemetrySpan_reserve(inworld_vector_TelemetrySpan* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_TelemetrySpan_empty(inworld_vector_TelemetrySpan* carg1);

SWIGIMPORT void inworld_vector_TelemetrySpan_clear(inworld_vector_TelemetrySpan* carg1);

SWIGIMPORT void inworld_vector_TelemetrySpan_push_back(inworld_vector_TelemetrySpan* carg1, inworld_Span* carg2);

SWIGIMPORT inworld_Span* inworld_vector_TelemetrySpan_get(inworld_vector_TelemetrySpan* carg1, int carg2);

SWIGIMPORT void inworld_vector_TelemetrySpan_set(inworld_vector_TelemetrySpan* carg1, int carg2, inworld_Span* carg3);

SWIGIMPORT void inworld_vector_TelemetrySpan_delete(inworld_vector_TelemetrySpan* carg1);

SWIGIMPORT inworld_vector_SpanData* inworld_vector_SpanData_new();

SWIGIMPORT inworld_vector_SpanData* inworld_vector_SpanData_copy(inworld_vector_SpanData* carg1);

SWIGIMPORT size_t inworld_vector_SpanData_size(inworld_vector_SpanData* carg1);

SWIGIMPORT size_t inworld_vector_SpanData_capacity(inworld_vector_SpanData* carg1);

SWIGIMPORT void inworld_vector_SpanData_reserve(inworld_vector_SpanData* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_SpanData_empty(inworld_vector_SpanData* carg1);

SWIGIMPORT void inworld_vector_SpanData_clear(inworld_vector_SpanData* carg1);

SWIGIMPORT void inworld_vector_SpanData_push_back(inworld_vector_SpanData* carg1, inworld_SpanData* carg2);

SWIGIMPORT inworld_SpanData* inworld_vector_SpanData_get(inworld_vector_SpanData* carg1, int carg2);

SWIGIMPORT void inworld_vector_SpanData_set(inworld_vector_SpanData* carg1, int carg2, inworld_SpanData* carg3);

SWIGIMPORT void inworld_vector_SpanData_delete(inworld_vector_SpanData* carg1);

SWIGIMPORT inworld_vector_SpanDataEvent* inworld_vector_SpanDataEvent_new();

SWIGIMPORT inworld_vector_SpanDataEvent* inworld_vector_SpanDataEvent_copy(inworld_vector_SpanDataEvent* carg1);

SWIGIMPORT size_t inworld_vector_SpanDataEvent_size(inworld_vector_SpanDataEvent* carg1);

SWIGIMPORT size_t inworld_vector_SpanDataEvent_capacity(inworld_vector_SpanDataEvent* carg1);

SWIGIMPORT void inworld_vector_SpanDataEvent_reserve(inworld_vector_SpanDataEvent* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_SpanDataEvent_empty(inworld_vector_SpanDataEvent* carg1);

SWIGIMPORT void inworld_vector_SpanDataEvent_clear(inworld_vector_SpanDataEvent* carg1);

SWIGIMPORT void inworld_vector_SpanDataEvent_push_back(inworld_vector_SpanDataEvent* carg1, inworld_SpanDataEvent* carg2);

SWIGIMPORT inworld_SpanDataEvent* inworld_vector_SpanDataEvent_get(inworld_vector_SpanDataEvent* carg1, int carg2);

SWIGIMPORT void inworld_vector_SpanDataEvent_set(inworld_vector_SpanDataEvent* carg1, int carg2, inworld_SpanDataEvent* carg3);

SWIGIMPORT void inworld_vector_SpanDataEvent_delete(inworld_vector_SpanDataEvent* carg1);

SWIGIMPORT inworld_vector_Edge* inworld_vector_Edge_new();

SWIGIMPORT inworld_vector_Edge* inworld_vector_Edge_copy(inworld_vector_Edge* carg1);

SWIGIMPORT size_t inworld_vector_Edge_size(inworld_vector_Edge* carg1);

SWIGIMPORT size_t inworld_vector_Edge_capacity(inworld_vector_Edge* carg1);

SWIGIMPORT void inworld_vector_Edge_reserve(inworld_vector_Edge* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_Edge_empty(inworld_vector_Edge* carg1);

SWIGIMPORT void inworld_vector_Edge_clear(inworld_vector_Edge* carg1);

SWIGIMPORT void inworld_vector_Edge_push_back(inworld_vector_Edge* carg1, inworld_Edge* carg2);

SWIGIMPORT inworld_Edge* inworld_vector_Edge_get(inworld_vector_Edge* carg1, int carg2);

SWIGIMPORT void inworld_vector_Edge_set(inworld_vector_Edge* carg1, int carg2, inworld_Edge* carg3);

SWIGIMPORT void inworld_vector_Edge_delete(inworld_vector_Edge* carg1);

SWIGIMPORT inworld_vector_char* inworld_vector_char_new();

SWIGIMPORT inworld_vector_char* inworld_vector_char_copy(inworld_vector_char* carg1);

SWIGIMPORT size_t inworld_vector_char_size(inworld_vector_char* carg1);

SWIGIMPORT size_t inworld_vector_char_capacity(inworld_vector_char* carg1);

SWIGIMPORT void inworld_vector_char_reserve(inworld_vector_char* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_char_empty(inworld_vector_char* carg1);

SWIGIMPORT void inworld_vector_char_clear(inworld_vector_char* carg1);

SWIGIMPORT void inworld_vector_char_push_back(inworld_vector_char* carg1, char carg2);

SWIGIMPORT char inworld_vector_char_get(inworld_vector_char* carg1, int carg2);

SWIGIMPORT void inworld_vector_char_set(inworld_vector_char* carg1, int carg2, char carg3);

SWIGIMPORT void inworld_vector_char_delete(inworld_vector_char* carg1);

SWIGIMPORT inworld_vector_char* inworld_memcpy_to_vector_char(const char * carg1, size_t carg2);

SWIGIMPORT inworld_vector_float* inworld_vector_float_new();

SWIGIMPORT inworld_vector_float* inworld_vector_float_copy(inworld_vector_float* carg1);

SWIGIMPORT size_t inworld_vector_float_size(inworld_vector_float* carg1);

SWIGIMPORT size_t inworld_vector_float_capacity(inworld_vector_float* carg1);

SWIGIMPORT void inworld_vector_float_reserve(inworld_vector_float* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_float_empty(inworld_vector_float* carg1);

SWIGIMPORT void inworld_vector_float_clear(inworld_vector_float* carg1);

SWIGIMPORT void inworld_vector_float_push_back(inworld_vector_float* carg1, float carg2);

SWIGIMPORT float inworld_vector_float_get(inworld_vector_float* carg1, int carg2);

SWIGIMPORT void inworld_vector_float_set(inworld_vector_float* carg1, int carg2, float carg3);

SWIGIMPORT void inworld_vector_float_delete(inworld_vector_float* carg1);

SWIGIMPORT inworld_vector_float* inworld_memcpy_to_vector_float(const float * carg1, size_t carg2);

SWIGIMPORT inworld_TransformationStreamDestructor* inworld_TransformationStreamDestructor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamDestructor_delete(inworld_TransformationStreamDestructor* carg1);

SWIGIMPORT inworld_TransformationStreamDestructor* inworld_TransformationStreamDestructor_copy(inworld_TransformationStreamDestructor* carg1);

SWIGIMPORT void inworld_TransformationStream_BaseData_To_string_delete(inworld_TransformationStream_BaseData_To_string* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_TransformationStream_BaseData_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_BaseData* carg1, inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_TransformationStream_BaseData_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_BaseData* carg1, inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string* carg2, inworld_TransformationStreamThreadedFilterExecutor_BaseData* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStream_BaseData_To_string_Read(inworld_TransformationStream_BaseData_To_string* carg1);

SWIGIMPORT bool inworld_TransformationStream_BaseData_To_string_HasNext(inworld_TransformationStream_BaseData_To_string* carg1);

SWIGIMPORT void inworld_TransformationStream_BaseData_To_string_Cancel(inworld_TransformationStream_BaseData_To_string* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_delete(inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_SetOutput(int carg1, inworld_StatusOr_string* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_copy(inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string* carg1);

SWIGIMPORT void inworld_TransformationStream_BaseData_To_Content_delete(inworld_TransformationStream_BaseData_To_Content* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_TransformationStream_BaseData_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_BaseData* carg1, inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_TransformationStream_BaseData_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_BaseData* carg1, inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content* carg2, inworld_TransformationStreamThreadedFilterExecutor_BaseData* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStream_BaseData_To_Content_Read(inworld_TransformationStream_BaseData_To_Content* carg1);

SWIGIMPORT bool inworld_TransformationStream_BaseData_To_Content_HasNext(inworld_TransformationStream_BaseData_To_Content* carg1);

SWIGIMPORT void inworld_TransformationStream_BaseData_To_Content_Cancel(inworld_TransformationStream_BaseData_To_Content* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_delete(inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_SetOutput(int carg1, inworld_StatusOr_Content* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_copy(inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content* carg1);

SWIGIMPORT void inworld_TransformationStream_BaseData_To_AudioChunk_delete(inworld_TransformationStream_BaseData_To_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TransformationStream_BaseData_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_BaseData* carg1, inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TransformationStream_BaseData_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_BaseData* carg1, inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk* carg2, inworld_TransformationStreamThreadedFilterExecutor_BaseData* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStream_BaseData_To_AudioChunk_Read(inworld_TransformationStream_BaseData_To_AudioChunk* carg1);

SWIGIMPORT bool inworld_TransformationStream_BaseData_To_AudioChunk_HasNext(inworld_TransformationStream_BaseData_To_AudioChunk* carg1);

SWIGIMPORT void inworld_TransformationStream_BaseData_To_AudioChunk_Cancel(inworld_TransformationStream_BaseData_To_AudioChunk* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_delete(inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_SetOutput(int carg1, inworld_StatusOr_AudioChunk* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_copy(inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk* carg1);

SWIGIMPORT void inworld_TransformationStream_BaseData_To_TTSOutput_delete(inworld_TransformationStream_BaseData_To_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_TransformationStream_BaseData_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_BaseData* carg1, inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_TransformationStream_BaseData_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_BaseData* carg1, inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput* carg2, inworld_TransformationStreamThreadedFilterExecutor_BaseData* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStream_BaseData_To_TTSOutput_Read(inworld_TransformationStream_BaseData_To_TTSOutput* carg1);

SWIGIMPORT bool inworld_TransformationStream_BaseData_To_TTSOutput_HasNext(inworld_TransformationStream_BaseData_To_TTSOutput* carg1);

SWIGIMPORT void inworld_TransformationStream_BaseData_To_TTSOutput_Cancel(inworld_TransformationStream_BaseData_To_TTSOutput* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_delete(inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_SetOutput(int carg1, inworld_StatusOr_TTSOutput* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_copy(inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput* carg1);

SWIGIMPORT void inworld_TransformationStream_BaseData_To_BaseData_delete(inworld_TransformationStream_BaseData_To_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_TransformationStream_BaseData_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_BaseData* carg1, inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_TransformationStream_BaseData_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_BaseData* carg1, inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData* carg2, inworld_TransformationStreamThreadedFilterExecutor_BaseData* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStream_BaseData_To_BaseData_Read(inworld_TransformationStream_BaseData_To_BaseData* carg1);

SWIGIMPORT bool inworld_TransformationStream_BaseData_To_BaseData_HasNext(inworld_TransformationStream_BaseData_To_BaseData* carg1);

SWIGIMPORT void inworld_TransformationStream_BaseData_To_BaseData_Cancel(inworld_TransformationStream_BaseData_To_BaseData* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_delete(inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_SetOutput(int carg1, inworld_StatusOr_BaseData* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData* inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_copy(inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData* carg1);

SWIGIMPORT void inworld_TransformationStream_string_To_Content_delete(inworld_TransformationStream_string_To_Content* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_TransformationStream_string_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_string* carg1, inworld_TransformationStreamThreadedTransformExecutor_string_To_Content* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_TransformationStream_string_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_string* carg1, inworld_TransformationStreamThreadedTransformExecutor_string_To_Content* carg2, inworld_TransformationStreamThreadedFilterExecutor_string* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStream_string_To_Content_Read(inworld_TransformationStream_string_To_Content* carg1);

SWIGIMPORT bool inworld_TransformationStream_string_To_Content_HasNext(inworld_TransformationStream_string_To_Content* carg1);

SWIGIMPORT void inworld_TransformationStream_string_To_Content_Cancel(inworld_TransformationStream_string_To_Content* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_string_To_Content* inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_delete(inworld_TransformationStreamThreadedTransformExecutor_string_To_Content* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_SetOutput(int carg1, inworld_StatusOr_Content* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_string_To_Content* inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_copy(inworld_TransformationStreamThreadedTransformExecutor_string_To_Content* carg1);

SWIGIMPORT void inworld_TransformationStream_string_To_AudioChunk_delete(inworld_TransformationStream_string_To_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TransformationStream_string_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_string* carg1, inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TransformationStream_string_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_string* carg1, inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk* carg2, inworld_TransformationStreamThreadedFilterExecutor_string* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStream_string_To_AudioChunk_Read(inworld_TransformationStream_string_To_AudioChunk* carg1);

SWIGIMPORT bool inworld_TransformationStream_string_To_AudioChunk_HasNext(inworld_TransformationStream_string_To_AudioChunk* carg1);

SWIGIMPORT void inworld_TransformationStream_string_To_AudioChunk_Cancel(inworld_TransformationStream_string_To_AudioChunk* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_delete(inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_SetOutput(int carg1, inworld_StatusOr_AudioChunk* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_copy(inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk* carg1);

SWIGIMPORT void inworld_TransformationStream_string_To_TTSOutput_delete(inworld_TransformationStream_string_To_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_TransformationStream_string_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_string* carg1, inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_TransformationStream_string_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_string* carg1, inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput* carg2, inworld_TransformationStreamThreadedFilterExecutor_string* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStream_string_To_TTSOutput_Read(inworld_TransformationStream_string_To_TTSOutput* carg1);

SWIGIMPORT bool inworld_TransformationStream_string_To_TTSOutput_HasNext(inworld_TransformationStream_string_To_TTSOutput* carg1);

SWIGIMPORT void inworld_TransformationStream_string_To_TTSOutput_Cancel(inworld_TransformationStream_string_To_TTSOutput* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_delete(inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_SetOutput(int carg1, inworld_StatusOr_TTSOutput* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_copy(inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput* carg1);

SWIGIMPORT void inworld_TransformationStream_string_To_BaseData_delete(inworld_TransformationStream_string_To_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_TransformationStream_string_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_string* carg1, inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_TransformationStream_string_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_string* carg1, inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData* carg2, inworld_TransformationStreamThreadedFilterExecutor_string* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStream_string_To_BaseData_Read(inworld_TransformationStream_string_To_BaseData* carg1);

SWIGIMPORT bool inworld_TransformationStream_string_To_BaseData_HasNext(inworld_TransformationStream_string_To_BaseData* carg1);

SWIGIMPORT void inworld_TransformationStream_string_To_BaseData_Cancel(inworld_TransformationStream_string_To_BaseData* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData* inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_delete(inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_SetOutput(int carg1, inworld_StatusOr_BaseData* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData* inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_copy(inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData* carg1);

SWIGIMPORT void inworld_TransformationStream_string_To_string_delete(inworld_TransformationStream_string_To_string* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_TransformationStream_string_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_string* carg1, inworld_TransformationStreamThreadedTransformExecutor_string_To_string* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_TransformationStream_string_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_string* carg1, inworld_TransformationStreamThreadedTransformExecutor_string_To_string* carg2, inworld_TransformationStreamThreadedFilterExecutor_string* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStream_string_To_string_Read(inworld_TransformationStream_string_To_string* carg1);

SWIGIMPORT bool inworld_TransformationStream_string_To_string_HasNext(inworld_TransformationStream_string_To_string* carg1);

SWIGIMPORT void inworld_TransformationStream_string_To_string_Cancel(inworld_TransformationStream_string_To_string* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_string_To_string* inworld_TransformationStreamThreadedTransformExecutor_string_To_string_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_string_To_string_delete(inworld_TransformationStreamThreadedTransformExecutor_string_To_string* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStreamThreadedTransformExecutor_string_To_string_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_string_To_string_SetOutput(int carg1, inworld_StatusOr_string* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_string_To_string* inworld_TransformationStreamThreadedTransformExecutor_string_To_string_copy(inworld_TransformationStreamThreadedTransformExecutor_string_To_string* carg1);

SWIGIMPORT void inworld_TransformationStream_Content_To_string_delete(inworld_TransformationStream_Content_To_string* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_TransformationStream_Content_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_Content* carg1, inworld_TransformationStreamThreadedTransformExecutor_Content_To_string* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_TransformationStream_Content_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_Content* carg1, inworld_TransformationStreamThreadedTransformExecutor_Content_To_string* carg2, inworld_TransformationStreamThreadedFilterExecutor_Content* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStream_Content_To_string_Read(inworld_TransformationStream_Content_To_string* carg1);

SWIGIMPORT bool inworld_TransformationStream_Content_To_string_HasNext(inworld_TransformationStream_Content_To_string* carg1);

SWIGIMPORT void inworld_TransformationStream_Content_To_string_Cancel(inworld_TransformationStream_Content_To_string* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_Content_To_string* inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_delete(inworld_TransformationStreamThreadedTransformExecutor_Content_To_string* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_SetOutput(int carg1, inworld_StatusOr_string* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_Content_To_string* inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_copy(inworld_TransformationStreamThreadedTransformExecutor_Content_To_string* carg1);

SWIGIMPORT void inworld_TransformationStream_Content_To_AudioChunk_delete(inworld_TransformationStream_Content_To_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TransformationStream_Content_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_Content* carg1, inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TransformationStream_Content_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_Content* carg1, inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk* carg2, inworld_TransformationStreamThreadedFilterExecutor_Content* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStream_Content_To_AudioChunk_Read(inworld_TransformationStream_Content_To_AudioChunk* carg1);

SWIGIMPORT bool inworld_TransformationStream_Content_To_AudioChunk_HasNext(inworld_TransformationStream_Content_To_AudioChunk* carg1);

SWIGIMPORT void inworld_TransformationStream_Content_To_AudioChunk_Cancel(inworld_TransformationStream_Content_To_AudioChunk* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_delete(inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_SetOutput(int carg1, inworld_StatusOr_AudioChunk* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_copy(inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk* carg1);

SWIGIMPORT void inworld_TransformationStream_Content_To_TTSOutput_delete(inworld_TransformationStream_Content_To_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_TransformationStream_Content_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_Content* carg1, inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_TransformationStream_Content_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_Content* carg1, inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput* carg2, inworld_TransformationStreamThreadedFilterExecutor_Content* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStream_Content_To_TTSOutput_Read(inworld_TransformationStream_Content_To_TTSOutput* carg1);

SWIGIMPORT bool inworld_TransformationStream_Content_To_TTSOutput_HasNext(inworld_TransformationStream_Content_To_TTSOutput* carg1);

SWIGIMPORT void inworld_TransformationStream_Content_To_TTSOutput_Cancel(inworld_TransformationStream_Content_To_TTSOutput* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_delete(inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_SetOutput(int carg1, inworld_StatusOr_TTSOutput* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_copy(inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput* carg1);

SWIGIMPORT void inworld_TransformationStream_Content_To_BaseData_delete(inworld_TransformationStream_Content_To_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_TransformationStream_Content_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_Content* carg1, inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_TransformationStream_Content_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_Content* carg1, inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData* carg2, inworld_TransformationStreamThreadedFilterExecutor_Content* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStream_Content_To_BaseData_Read(inworld_TransformationStream_Content_To_BaseData* carg1);

SWIGIMPORT bool inworld_TransformationStream_Content_To_BaseData_HasNext(inworld_TransformationStream_Content_To_BaseData* carg1);

SWIGIMPORT void inworld_TransformationStream_Content_To_BaseData_Cancel(inworld_TransformationStream_Content_To_BaseData* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData* inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_delete(inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_SetOutput(int carg1, inworld_StatusOr_BaseData* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData* inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_copy(inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData* carg1);

SWIGIMPORT void inworld_TransformationStream_Content_To_Content_delete(inworld_TransformationStream_Content_To_Content* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_TransformationStream_Content_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_Content* carg1, inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_TransformationStream_Content_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_Content* carg1, inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content* carg2, inworld_TransformationStreamThreadedFilterExecutor_Content* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStream_Content_To_Content_Read(inworld_TransformationStream_Content_To_Content* carg1);

SWIGIMPORT bool inworld_TransformationStream_Content_To_Content_HasNext(inworld_TransformationStream_Content_To_Content* carg1);

SWIGIMPORT void inworld_TransformationStream_Content_To_Content_Cancel(inworld_TransformationStream_Content_To_Content* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content* inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_delete(inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_SetOutput(int carg1, inworld_StatusOr_Content* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content* inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_copy(inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content* carg1);

SWIGIMPORT void inworld_TransformationStream_AudioChunk_To_string_delete(inworld_TransformationStream_AudioChunk_To_string* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_TransformationStream_AudioChunk_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_AudioChunk* carg1, inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_TransformationStream_AudioChunk_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_AudioChunk* carg1, inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string* carg2, inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStream_AudioChunk_To_string_Read(inworld_TransformationStream_AudioChunk_To_string* carg1);

SWIGIMPORT bool inworld_TransformationStream_AudioChunk_To_string_HasNext(inworld_TransformationStream_AudioChunk_To_string* carg1);

SWIGIMPORT void inworld_TransformationStream_AudioChunk_To_string_Cancel(inworld_TransformationStream_AudioChunk_To_string* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_delete(inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_SetOutput(int carg1, inworld_StatusOr_string* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_copy(inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string* carg1);

SWIGIMPORT void inworld_TransformationStream_AudioChunk_To_Content_delete(inworld_TransformationStream_AudioChunk_To_Content* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_TransformationStream_AudioChunk_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_AudioChunk* carg1, inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_TransformationStream_AudioChunk_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_AudioChunk* carg1, inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content* carg2, inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStream_AudioChunk_To_Content_Read(inworld_TransformationStream_AudioChunk_To_Content* carg1);

SWIGIMPORT bool inworld_TransformationStream_AudioChunk_To_Content_HasNext(inworld_TransformationStream_AudioChunk_To_Content* carg1);

SWIGIMPORT void inworld_TransformationStream_AudioChunk_To_Content_Cancel(inworld_TransformationStream_AudioChunk_To_Content* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_delete(inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_SetOutput(int carg1, inworld_StatusOr_Content* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_copy(inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content* carg1);

SWIGIMPORT void inworld_TransformationStream_AudioChunk_To_TTSOutput_delete(inworld_TransformationStream_AudioChunk_To_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_TransformationStream_AudioChunk_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_AudioChunk* carg1, inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_TransformationStream_AudioChunk_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_AudioChunk* carg1, inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput* carg2, inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStream_AudioChunk_To_TTSOutput_Read(inworld_TransformationStream_AudioChunk_To_TTSOutput* carg1);

SWIGIMPORT bool inworld_TransformationStream_AudioChunk_To_TTSOutput_HasNext(inworld_TransformationStream_AudioChunk_To_TTSOutput* carg1);

SWIGIMPORT void inworld_TransformationStream_AudioChunk_To_TTSOutput_Cancel(inworld_TransformationStream_AudioChunk_To_TTSOutput* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_delete(inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_SetOutput(int carg1, inworld_StatusOr_TTSOutput* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_copy(inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput* carg1);

SWIGIMPORT void inworld_TransformationStream_AudioChunk_To_BaseData_delete(inworld_TransformationStream_AudioChunk_To_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_TransformationStream_AudioChunk_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_AudioChunk* carg1, inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_TransformationStream_AudioChunk_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_AudioChunk* carg1, inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData* carg2, inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStream_AudioChunk_To_BaseData_Read(inworld_TransformationStream_AudioChunk_To_BaseData* carg1);

SWIGIMPORT bool inworld_TransformationStream_AudioChunk_To_BaseData_HasNext(inworld_TransformationStream_AudioChunk_To_BaseData* carg1);

SWIGIMPORT void inworld_TransformationStream_AudioChunk_To_BaseData_Cancel(inworld_TransformationStream_AudioChunk_To_BaseData* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_delete(inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_SetOutput(int carg1, inworld_StatusOr_BaseData* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_copy(inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData* carg1);

SWIGIMPORT void inworld_TransformationStream_AudioChunk_To_AudioChunk_delete(inworld_TransformationStream_AudioChunk_To_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TransformationStream_AudioChunk_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_AudioChunk* carg1, inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TransformationStream_AudioChunk_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_AudioChunk* carg1, inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk* carg2, inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStream_AudioChunk_To_AudioChunk_Read(inworld_TransformationStream_AudioChunk_To_AudioChunk* carg1);

SWIGIMPORT bool inworld_TransformationStream_AudioChunk_To_AudioChunk_HasNext(inworld_TransformationStream_AudioChunk_To_AudioChunk* carg1);

SWIGIMPORT void inworld_TransformationStream_AudioChunk_To_AudioChunk_Cancel(inworld_TransformationStream_AudioChunk_To_AudioChunk* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_delete(inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_SetOutput(int carg1, inworld_StatusOr_AudioChunk* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_copy(inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk* carg1);

SWIGIMPORT void inworld_TransformationStream_TTSOutput_To_string_delete(inworld_TransformationStream_TTSOutput_To_string* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_TransformationStream_TTSOutput_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_TTSOutput* carg1, inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_TransformationStream_TTSOutput_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_TTSOutput* carg1, inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string* carg2, inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStream_TTSOutput_To_string_Read(inworld_TransformationStream_TTSOutput_To_string* carg1);

SWIGIMPORT bool inworld_TransformationStream_TTSOutput_To_string_HasNext(inworld_TransformationStream_TTSOutput_To_string* carg1);

SWIGIMPORT void inworld_TransformationStream_TTSOutput_To_string_Cancel(inworld_TransformationStream_TTSOutput_To_string* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_delete(inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string* carg1);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_SetOutput(int carg1, inworld_StatusOr_string* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_copy(inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string* carg1);

SWIGIMPORT void inworld_TransformationStream_TTSOutput_To_Content_delete(inworld_TransformationStream_TTSOutput_To_Content* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_TransformationStream_TTSOutput_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_TTSOutput* carg1, inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_TransformationStream_TTSOutput_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_TTSOutput* carg1, inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content* carg2, inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStream_TTSOutput_To_Content_Read(inworld_TransformationStream_TTSOutput_To_Content* carg1);

SWIGIMPORT bool inworld_TransformationStream_TTSOutput_To_Content_HasNext(inworld_TransformationStream_TTSOutput_To_Content* carg1);

SWIGIMPORT void inworld_TransformationStream_TTSOutput_To_Content_Cancel(inworld_TransformationStream_TTSOutput_To_Content* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_delete(inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content* carg1);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_SetOutput(int carg1, inworld_StatusOr_Content* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_copy(inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content* carg1);

SWIGIMPORT void inworld_TransformationStream_TTSOutput_To_AudioChunk_delete(inworld_TransformationStream_TTSOutput_To_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TransformationStream_TTSOutput_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_TTSOutput* carg1, inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TransformationStream_TTSOutput_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_TTSOutput* carg1, inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk* carg2, inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStream_TTSOutput_To_AudioChunk_Read(inworld_TransformationStream_TTSOutput_To_AudioChunk* carg1);

SWIGIMPORT bool inworld_TransformationStream_TTSOutput_To_AudioChunk_HasNext(inworld_TransformationStream_TTSOutput_To_AudioChunk* carg1);

SWIGIMPORT void inworld_TransformationStream_TTSOutput_To_AudioChunk_Cancel(inworld_TransformationStream_TTSOutput_To_AudioChunk* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_delete(inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_SetOutput(int carg1, inworld_StatusOr_AudioChunk* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_copy(inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk* carg1);

SWIGIMPORT void inworld_TransformationStream_TTSOutput_To_BaseData_delete(inworld_TransformationStream_TTSOutput_To_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_TransformationStream_TTSOutput_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_TTSOutput* carg1, inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_BaseData* inworld_TransformationStream_TTSOutput_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_TTSOutput* carg1, inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData* carg2, inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStream_TTSOutput_To_BaseData_Read(inworld_TransformationStream_TTSOutput_To_BaseData* carg1);

SWIGIMPORT bool inworld_TransformationStream_TTSOutput_To_BaseData_HasNext(inworld_TransformationStream_TTSOutput_To_BaseData* carg1);

SWIGIMPORT void inworld_TransformationStream_TTSOutput_To_BaseData_Cancel(inworld_TransformationStream_TTSOutput_To_BaseData* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_delete(inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_SetOutput(int carg1, inworld_StatusOr_BaseData* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_copy(inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData* carg1);

SWIGIMPORT void inworld_TransformationStream_TTSOutput_To_TTSOutput_delete(inworld_TransformationStream_TTSOutput_To_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_TransformationStream_TTSOutput_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_TTSOutput* carg1, inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput* carg2, inworld_TransformationStreamDestructor* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_TTSOutput* inworld_TransformationStream_TTSOutput_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(inworld_InputStream_TTSOutput* carg1, inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput* carg2, inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* carg3, inworld_TransformationStreamDestructor* carg4);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStream_TTSOutput_To_TTSOutput_Read(inworld_TransformationStream_TTSOutput_To_TTSOutput* carg1);

SWIGIMPORT bool inworld_TransformationStream_TTSOutput_To_TTSOutput_HasNext(inworld_TransformationStream_TTSOutput_To_TTSOutput* carg1);

SWIGIMPORT void inworld_TransformationStream_TTSOutput_To_TTSOutput_Cancel(inworld_TransformationStream_TTSOutput_To_TTSOutput* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_delete(inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_SetOutput(int carg1, inworld_StatusOr_TTSOutput* carg2);

SWIGIMPORT inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput* inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_copy(inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedFilterExecutor_BaseData* inworld_TransformationStreamThreadedFilterExecutor_BaseData_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedFilterExecutor_BaseData_delete(inworld_TransformationStreamThreadedFilterExecutor_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TransformationStreamThreadedFilterExecutor_BaseData_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedFilterExecutor_BaseData_SetOutput(int carg1, bool carg2);

SWIGIMPORT inworld_TransformationStreamThreadedFilterExecutor_BaseData* inworld_TransformationStreamThreadedFilterExecutor_BaseData_copy(inworld_TransformationStreamThreadedFilterExecutor_BaseData* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedFilterExecutor_string* inworld_TransformationStreamThreadedFilterExecutor_string_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedFilterExecutor_string_delete(inworld_TransformationStreamThreadedFilterExecutor_string* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_TransformationStreamThreadedFilterExecutor_string_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedFilterExecutor_string_SetOutput(int carg1, bool carg2);

SWIGIMPORT inworld_TransformationStreamThreadedFilterExecutor_string* inworld_TransformationStreamThreadedFilterExecutor_string_copy(inworld_TransformationStreamThreadedFilterExecutor_string* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedFilterExecutor_Content* inworld_TransformationStreamThreadedFilterExecutor_Content_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedFilterExecutor_Content_delete(inworld_TransformationStreamThreadedFilterExecutor_Content* carg1);

SWIGIMPORT inworld_StatusOr_Content* inworld_TransformationStreamThreadedFilterExecutor_Content_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedFilterExecutor_Content_SetOutput(int carg1, bool carg2);

SWIGIMPORT inworld_TransformationStreamThreadedFilterExecutor_Content* inworld_TransformationStreamThreadedFilterExecutor_Content_copy(inworld_TransformationStreamThreadedFilterExecutor_Content* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_delete(inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_SetOutput(int carg1, bool carg2);

SWIGIMPORT inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_copy(inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* carg1);

SWIGIMPORT inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_delete(inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_GetInput(int carg1);

SWIGIMPORT void inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_SetOutput(int carg1, bool carg2);

SWIGIMPORT inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_copy(inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* carg1);

SWIGIMPORT void inworld_AgentSpeech_agent_name_set(inworld_AgentSpeech* carg1, const char * carg2);

SWIGIMPORT const char * inworld_AgentSpeech_agent_name_get(inworld_AgentSpeech* carg1);

SWIGIMPORT void inworld_AgentSpeech_utterance_set(inworld_AgentSpeech* carg1, const char * carg2);

SWIGIMPORT const char * inworld_AgentSpeech_utterance_get(inworld_AgentSpeech* carg1);

SWIGIMPORT inworld_AgentSpeech* inworld_AgentSpeech_copy(inworld_AgentSpeech* carg1);

SWIGIMPORT void inworld_AgentSpeech_delete(inworld_AgentSpeech* carg1);

SWIGIMPORT void inworld_AgentAction_agent_name_set(inworld_AgentAction* carg1, const char * carg2);

SWIGIMPORT const char * inworld_AgentAction_agent_name_get(inworld_AgentAction* carg1);

SWIGIMPORT void inworld_AgentAction_name_set(inworld_AgentAction* carg1, const char * carg2);

SWIGIMPORT const char * inworld_AgentAction_name_get(inworld_AgentAction* carg1);

SWIGIMPORT void inworld_AgentAction_set_parameter(inworld_AgentAction* carg1, const char * carg2, const char * carg3);

SWIGIMPORT bool inworld_AgentAction_contains_parameter(inworld_AgentAction* carg1, const char * carg2);

SWIGIMPORT const char * inworld_AgentAction_get_parameter(inworld_AgentAction* carg1, const char * carg2);

SWIGIMPORT inworld_AgentAction* inworld_AgentAction_copy(inworld_AgentAction* carg1);

SWIGIMPORT void inworld_AgentAction_delete(inworld_AgentAction* carg1);

SWIGIMPORT inworld_AgentSpeech* inworld_Event_speech(inworld_Event* carg1);

SWIGIMPORT inworld_AgentAction* inworld_Event_action(inworld_Event* carg1);

SWIGIMPORT bool inworld_Event_is_valid(inworld_Event* carg1);

SWIGIMPORT inworld_Event* inworld_Event_new();

SWIGIMPORT inworld_Event* inworld_Event_copy(inworld_Event* carg1);

SWIGIMPORT void inworld_Event_delete(inworld_Event* carg1);

SWIGIMPORT void inworld_Intent_name_set(inworld_Intent* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Intent_name_get(inworld_Intent* carg1);

SWIGIMPORT void inworld_Intent_phrases_set(inworld_Intent* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_Intent_phrases_get(inworld_Intent* carg1);

SWIGIMPORT inworld_Intent* inworld_Intent_new();

SWIGIMPORT inworld_Intent* inworld_Intent_copy(inworld_Intent* carg1);

SWIGIMPORT void inworld_Intent_delete(inworld_Intent* carg1);

SWIGIMPORT void inworld_CompiledIntent_name_set(inworld_CompiledIntent* carg1, const char * carg2);

SWIGIMPORT const char * inworld_CompiledIntent_name_get(inworld_CompiledIntent* carg1);

SWIGIMPORT void inworld_CompiledIntent_normalized_phrases_set(inworld_CompiledIntent* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_CompiledIntent_normalized_phrases_get(inworld_CompiledIntent* carg1);

SWIGIMPORT void inworld_CompiledIntent_phrase_embeddings_set(inworld_CompiledIntent* carg1, inworld_vector_vector_float* carg2);

SWIGIMPORT inworld_vector_vector_float* inworld_CompiledIntent_phrase_embeddings_get(inworld_CompiledIntent* carg1);

SWIGIMPORT inworld_CompiledIntent* inworld_CompiledIntent_new();

SWIGIMPORT inworld_CompiledIntent* inworld_CompiledIntent_copy(inworld_CompiledIntent* carg1);

SWIGIMPORT void inworld_CompiledIntent_delete(inworld_CompiledIntent* carg1);

SWIGIMPORT inworld_StatusOr_Language* inworld_StatusOr_Language_new();

SWIGIMPORT inworld_StatusOr_Language* inworld_StatusOr_Language_new_rcinworld_library_Language(inworld_Language* carg1);

SWIGIMPORT inworld_StatusOr_Language* inworld_StatusOr_Language_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_Language_ok(inworld_StatusOr_Language* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_Language_status(inworld_StatusOr_Language* carg1);

SWIGIMPORT inworld_Language* inworld_StatusOr_Language_value(inworld_StatusOr_Language* carg1);

SWIGIMPORT inworld_StatusOr_Language* inworld_StatusOr_Language_copy(inworld_StatusOr_Language* carg1);

SWIGIMPORT void inworld_StatusOr_Language_delete(inworld_StatusOr_Language* carg1);

SWIGIMPORT void inworld_Language_lang_set(inworld_Language* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Language_lang_get(inworld_Language* carg1);

SWIGIMPORT void inworld_Language_locale_set(inworld_Language* carg1, inworld_optional_string* carg2);

SWIGIMPORT inworld_optional_string* inworld_Language_locale_get(inworld_Language* carg1);

SWIGIMPORT inworld_StatusOr_Language* inworld_Language_FromString(const char * carg1);

SWIGIMPORT const char * inworld_Language_ToString(inworld_Language* carg1);

SWIGIMPORT inworld_Language* inworld_Language_English();

SWIGIMPORT inworld_Language* inworld_Language_Chinese();

SWIGIMPORT inworld_Language* inworld_Language_Korean();

SWIGIMPORT inworld_Language* inworld_Language_Japanese();

SWIGIMPORT inworld_Language* inworld_Language_Russian();

SWIGIMPORT inworld_Language* inworld_Language_Spanish();

SWIGIMPORT inworld_Language* inworld_Language_French();

SWIGIMPORT inworld_Language* inworld_Language_German();

SWIGIMPORT inworld_Language* inworld_Language_Italian();

SWIGIMPORT inworld_Language* inworld_Language_Portuguese();

SWIGIMPORT inworld_Language* inworld_Language_Arabic();

SWIGIMPORT inworld_Language* inworld_Language_Hindi();

SWIGIMPORT inworld_Language* inworld_Language_Dutch();

SWIGIMPORT inworld_Language* inworld_Language_Swedish();

SWIGIMPORT inworld_Language* inworld_Language_Norwegian();

SWIGIMPORT inworld_Language* inworld_Language_Danish();

SWIGIMPORT inworld_Language* inworld_Language_Finnish();

SWIGIMPORT inworld_Language* inworld_Language_Polish();

SWIGIMPORT inworld_Language* inworld_Language_Turkish();

SWIGIMPORT inworld_Language* inworld_Language_Thai();

SWIGIMPORT inworld_Language* inworld_Language_Vietnamese();

SWIGIMPORT inworld_Language* inworld_Language_Indonesian();

SWIGIMPORT inworld_Language* inworld_Language_Malay();

SWIGIMPORT inworld_Language* inworld_Language_Hebrew();

SWIGIMPORT inworld_Language* inworld_Language_Ukrainian();

SWIGIMPORT inworld_Language* inworld_Language_new();

SWIGIMPORT inworld_Language* inworld_Language_copy(inworld_Language* carg1);

SWIGIMPORT void inworld_Language_delete(inworld_Language* carg1);

SWIGIMPORT const char * inworld_DeviceInfo_name_get(inworld_DeviceInfo* carg1);

SWIGIMPORT unsigned long long inworld_DeviceInfo_free_memory_bytes_get(inworld_DeviceInfo* carg1);

SWIGIMPORT unsigned long long inworld_DeviceInfo_total_memory_bytes_get(inworld_DeviceInfo* carg1);

SWIGIMPORT inworld_DeviceInfo* inworld_DeviceInfo_new();

SWIGIMPORT inworld_DeviceInfo* inworld_DeviceInfo_copy(inworld_DeviceInfo* carg1);

SWIGIMPORT void inworld_DeviceInfo_delete(inworld_DeviceInfo* carg1);

SWIGIMPORT enum inworld_DeviceType inworld_Device_type(inworld_Device* carg1);

SWIGIMPORT signed char inworld_Device_index(inworld_Device* carg1);

SWIGIMPORT inworld_DeviceInfo* inworld_Device_info(inworld_Device* carg1);

SWIGIMPORT void inworld_Device_delete(inworld_Device* carg1);

SWIGIMPORT const char * inworld_DeviceTypeToString(enum inworld_DeviceType carg1);

SWIGIMPORT void inworld_DeviceRegistry_delete(inworld_DeviceRegistry* carg1);

SWIGIMPORT inworld_DeviceRegistry* inworld_DeviceRegistry_GetInstance();

SWIGIMPORT inworld_vector_Device* inworld_DeviceRegistry_GetAvailableDevices(inworld_DeviceRegistry* carg1);

SWIGIMPORT void inworld_ModelProperties_model_id_set(inworld_ModelProperties* carg1, const char * carg2);

SWIGIMPORT const char * inworld_ModelProperties_model_id_get(inworld_ModelProperties* carg1);

SWIGIMPORT inworld_ModelProperties* inworld_ModelProperties_new();

SWIGIMPORT inworld_ModelProperties* inworld_ModelProperties_copy(inworld_ModelProperties* carg1);

SWIGIMPORT void inworld_ModelProperties_delete(inworld_ModelProperties* carg1);

SWIGIMPORT void inworld_ModelInterface_delete(inworld_ModelInterface* carg1);

SWIGIMPORT inworld_ModelProperties* inworld_ModelInterface_model_properties(inworld_ModelInterface* carg1);

SWIGIMPORT bool inworld_ModelInterface_is_valid(inworld_ModelInterface* carg1);

SWIGIMPORT void inworld_TextEmbedderInterface_delete(inworld_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_StatusOr_vector_float* inworld_TextEmbedderInterface_Embed(inworld_TextEmbedderInterface* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_vector_vector_float* inworld_TextEmbedderInterface_EmbedBatch(inworld_TextEmbedderInterface* carg1, inworld_vector_string* carg2);

SWIGIMPORT bool inworld_TextEmbedderInterface_is_valid(inworld_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_ModelProperties* inworld_TextEmbedderInterface_model_properties(inworld_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_optional_LocalTextEmbedderConfig* inworld_optional_LocalTextEmbedderConfig_new();

SWIGIMPORT inworld_optional_LocalTextEmbedderConfig* inworld_optional_LocalTextEmbedderConfig_new_rcinworld_LocalTextEmbedderConfig(inworld_LocalTextEmbedderConfig* carg1);

SWIGIMPORT inworld_optional_LocalTextEmbedderConfig* inworld_optional_LocalTextEmbedderConfig_copy(inworld_optional_LocalTextEmbedderConfig* carg1);

SWIGIMPORT void inworld_optional_LocalTextEmbedderConfig_delete(inworld_optional_LocalTextEmbedderConfig* carg1);

SWIGIMPORT bool inworld_optional_LocalTextEmbedderConfig_has_value(inworld_optional_LocalTextEmbedderConfig* carg1);

SWIGIMPORT inworld_LocalTextEmbedderConfig* inworld_optional_LocalTextEmbedderConfig_value(inworld_optional_LocalTextEmbedderConfig* carg1);

SWIGIMPORT inworld_LocalTextEmbedderConfig* inworld_optional_LocalTextEmbedderConfig_valueConst(inworld_optional_LocalTextEmbedderConfig* carg1);

SWIGIMPORT inworld_LocalTextEmbedderConfig* inworld_optional_LocalTextEmbedderConfig_value_or(inworld_optional_LocalTextEmbedderConfig* carg1, inworld_LocalTextEmbedderConfig* carg2);

SWIGIMPORT void inworld_optional_LocalTextEmbedderConfig_reset(inworld_optional_LocalTextEmbedderConfig* carg1);

SWIGIMPORT inworld_LocalTextEmbedderConfig* inworld_optional_LocalTextEmbedderConfig_get(inworld_optional_LocalTextEmbedderConfig* carg1);

SWIGIMPORT inworld_LocalTextEmbedderConfig* inworld_optional_LocalTextEmbedderConfig_getConst(inworld_optional_LocalTextEmbedderConfig* carg1);

SWIGIMPORT inworld_LocalTextEmbedderConfig* inworld_optional_LocalTextEmbedderConfig_get_value(inworld_optional_LocalTextEmbedderConfig* carg1);

SWIGIMPORT void inworld_optional_LocalTextEmbedderConfig_set_value(inworld_optional_LocalTextEmbedderConfig* carg1, inworld_LocalTextEmbedderConfig* carg2);

SWIGIMPORT inworld_optional_RemoteTextEmbedderConfig* inworld_optional_RemoteTextEmbedderConfig_new();

SWIGIMPORT inworld_optional_RemoteTextEmbedderConfig* inworld_optional_RemoteTextEmbedderConfig_new_rcinworld_RemoteTextEmbedderConfig(inworld_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT inworld_optional_RemoteTextEmbedderConfig* inworld_optional_RemoteTextEmbedderConfig_copy(inworld_optional_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteTextEmbedderConfig_delete(inworld_optional_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT bool inworld_optional_RemoteTextEmbedderConfig_has_value(inworld_optional_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT inworld_RemoteTextEmbedderConfig* inworld_optional_RemoteTextEmbedderConfig_value(inworld_optional_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT inworld_RemoteTextEmbedderConfig* inworld_optional_RemoteTextEmbedderConfig_valueConst(inworld_optional_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT inworld_RemoteTextEmbedderConfig* inworld_optional_RemoteTextEmbedderConfig_value_or(inworld_optional_RemoteTextEmbedderConfig* carg1, inworld_RemoteTextEmbedderConfig* carg2);

SWIGIMPORT void inworld_optional_RemoteTextEmbedderConfig_reset(inworld_optional_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT inworld_RemoteTextEmbedderConfig* inworld_optional_RemoteTextEmbedderConfig_get(inworld_optional_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT inworld_RemoteTextEmbedderConfig* inworld_optional_RemoteTextEmbedderConfig_getConst(inworld_optional_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT inworld_RemoteTextEmbedderConfig* inworld_optional_RemoteTextEmbedderConfig_get_value(inworld_optional_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteTextEmbedderConfig_set_value(inworld_optional_RemoteTextEmbedderConfig* carg1, inworld_RemoteTextEmbedderConfig* carg2);

SWIGIMPORT void inworld_LocalTextEmbedderConfig_model_path_set(inworld_LocalTextEmbedderConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LocalTextEmbedderConfig_model_path_get(inworld_LocalTextEmbedderConfig* carg1);

SWIGIMPORT void inworld_LocalTextEmbedderConfig_device_set(inworld_LocalTextEmbedderConfig* carg1, inworld_Device* carg2);

SWIGIMPORT inworld_Device* inworld_LocalTextEmbedderConfig_device_get(inworld_LocalTextEmbedderConfig* carg1);

SWIGIMPORT inworld_LocalTextEmbedderConfig* inworld_LocalTextEmbedderConfig_new();

SWIGIMPORT inworld_LocalTextEmbedderConfig* inworld_LocalTextEmbedderConfig_copy(inworld_LocalTextEmbedderConfig* carg1);

SWIGIMPORT void inworld_LocalTextEmbedderConfig_delete(inworld_LocalTextEmbedderConfig* carg1);

SWIGIMPORT void inworld_RemoteTextEmbedderConfig_provider_set(inworld_RemoteTextEmbedderConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RemoteTextEmbedderConfig_provider_get(inworld_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT void inworld_RemoteTextEmbedderConfig_model_name_set(inworld_RemoteTextEmbedderConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RemoteTextEmbedderConfig_model_name_get(inworld_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT void inworld_RemoteTextEmbedderConfig_api_key_set(inworld_RemoteTextEmbedderConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RemoteTextEmbedderConfig_api_key_get(inworld_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT inworld_RemoteTextEmbedderConfig* inworld_RemoteTextEmbedderConfig_new();

SWIGIMPORT inworld_RemoteTextEmbedderConfig* inworld_RemoteTextEmbedderConfig_copy(inworld_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT void inworld_RemoteTextEmbedderConfig_delete(inworld_RemoteTextEmbedderConfig* carg1);

SWIGIMPORT bool inworld_TextEmbedderCreationConfig_has_local_config(inworld_TextEmbedderCreationConfig* carg1);

SWIGIMPORT bool inworld_TextEmbedderCreationConfig_has_remote_config(inworld_TextEmbedderCreationConfig* carg1);

SWIGIMPORT inworld_optional_LocalTextEmbedderConfig* inworld_TextEmbedderCreationConfig_get_local_config(inworld_TextEmbedderCreationConfig* carg1);

SWIGIMPORT inworld_optional_RemoteTextEmbedderConfig* inworld_TextEmbedderCreationConfig_get_remote_config(inworld_TextEmbedderCreationConfig* carg1);

SWIGIMPORT void inworld_TextEmbedderCreationConfig_set_local_config(inworld_TextEmbedderCreationConfig* carg1, inworld_LocalTextEmbedderConfig* carg2);

SWIGIMPORT void inworld_TextEmbedderCreationConfig_set_remote_config(inworld_TextEmbedderCreationConfig* carg1, inworld_RemoteTextEmbedderConfig* carg2);

SWIGIMPORT inworld_TextEmbedderCreationConfig* inworld_TextEmbedderCreationConfig_new();

SWIGIMPORT inworld_TextEmbedderCreationConfig* inworld_TextEmbedderCreationConfig_copy(inworld_TextEmbedderCreationConfig* carg1);

SWIGIMPORT void inworld_TextEmbedderCreationConfig_delete(inworld_TextEmbedderCreationConfig* carg1);

SWIGIMPORT void inworld_TextEmbedderFactory_delete(inworld_TextEmbedderFactory* carg1);

SWIGIMPORT inworld_StatusOr_TextEmbedderInterface* inworld_TextEmbedderFactory_CreateTextEmbedder(inworld_TextEmbedderFactory* carg1, inworld_TextEmbedderCreationConfig* carg2);

SWIGIMPORT inworld_TextEmbedderFactory* inworld_TextEmbedderFactory_new();

SWIGIMPORT inworld_TextEmbedderFactory* inworld_TextEmbedderFactory_copy(inworld_TextEmbedderFactory* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_RenderJinja(const char * carg1, const char * carg2);

SWIGIMPORT inworld_optional_float* inworld_optional_float_new();

SWIGIMPORT inworld_optional_float* inworld_optional_float_new_rcf(float carg1);

SWIGIMPORT inworld_optional_float* inworld_optional_float_copy(inworld_optional_float* carg1);

SWIGIMPORT void inworld_optional_float_delete(inworld_optional_float* carg1);

SWIGIMPORT bool inworld_optional_float_has_value(inworld_optional_float* carg1);

SWIGIMPORT float * inworld_optional_float_value(inworld_optional_float* carg1);

SWIGIMPORT float inworld_optional_float_valueConst(inworld_optional_float* carg1);

SWIGIMPORT float inworld_optional_float_value_or(inworld_optional_float* carg1, float carg2);

SWIGIMPORT void inworld_optional_float_reset(inworld_optional_float* carg1);

SWIGIMPORT float * inworld_optional_float_get(inworld_optional_float* carg1);

SWIGIMPORT float inworld_optional_float_getConst(inworld_optional_float* carg1);

SWIGIMPORT float * inworld_optional_float_get_value(inworld_optional_float* carg1);

SWIGIMPORT void inworld_optional_float_set_value(inworld_optional_float* carg1, float * carg2);

SWIGIMPORT inworld_optional_int* inworld_optional_int_new();

SWIGIMPORT inworld_optional_int* inworld_optional_int_new_rci(int carg1);

SWIGIMPORT inworld_optional_int* inworld_optional_int_copy(inworld_optional_int* carg1);

SWIGIMPORT void inworld_optional_int_delete(inworld_optional_int* carg1);

SWIGIMPORT bool inworld_optional_int_has_value(inworld_optional_int* carg1);

SWIGIMPORT int * inworld_optional_int_value(inworld_optional_int* carg1);

SWIGIMPORT int inworld_optional_int_valueConst(inworld_optional_int* carg1);

SWIGIMPORT int inworld_optional_int_value_or(inworld_optional_int* carg1, int carg2);

SWIGIMPORT void inworld_optional_int_reset(inworld_optional_int* carg1);

SWIGIMPORT int * inworld_optional_int_get(inworld_optional_int* carg1);

SWIGIMPORT int inworld_optional_int_getConst(inworld_optional_int* carg1);

SWIGIMPORT int * inworld_optional_int_get_value(inworld_optional_int* carg1);

SWIGIMPORT void inworld_optional_int_set_value(inworld_optional_int* carg1, int * carg2);

SWIGIMPORT inworld_optional_sizet* inworld_optional_sizet_new();

SWIGIMPORT inworld_optional_sizet* inworld_optional_sizet_new_rcsize_t(size_t carg1);

SWIGIMPORT inworld_optional_sizet* inworld_optional_sizet_copy(inworld_optional_sizet* carg1);

SWIGIMPORT void inworld_optional_sizet_delete(inworld_optional_sizet* carg1);

SWIGIMPORT bool inworld_optional_sizet_has_value(inworld_optional_sizet* carg1);

SWIGIMPORT size_t * inworld_optional_sizet_value(inworld_optional_sizet* carg1);

SWIGIMPORT size_t inworld_optional_sizet_valueConst(inworld_optional_sizet* carg1);

SWIGIMPORT size_t inworld_optional_sizet_value_or(inworld_optional_sizet* carg1, size_t carg2);

SWIGIMPORT void inworld_optional_sizet_reset(inworld_optional_sizet* carg1);

SWIGIMPORT size_t * inworld_optional_sizet_get(inworld_optional_sizet* carg1);

SWIGIMPORT size_t inworld_optional_sizet_getConst(inworld_optional_sizet* carg1);

SWIGIMPORT size_t * inworld_optional_sizet_get_value(inworld_optional_sizet* carg1);

SWIGIMPORT void inworld_optional_sizet_set_value(inworld_optional_sizet* carg1, size_t * carg2);

SWIGIMPORT inworld_optional_string* inworld_optional_string_new();

SWIGIMPORT inworld_optional_string* inworld_optional_string_new_rcstd_string(const char * carg1);

SWIGIMPORT inworld_optional_string* inworld_optional_string_copy(inworld_optional_string* carg1);

SWIGIMPORT void inworld_optional_string_delete(inworld_optional_string* carg1);

SWIGIMPORT bool inworld_optional_string_has_value(inworld_optional_string* carg1);

SWIGIMPORT char * inworld_optional_string_value(inworld_optional_string* carg1);

SWIGIMPORT const char * inworld_optional_string_valueConst(inworld_optional_string* carg1);

SWIGIMPORT const char * inworld_optional_string_value_or(inworld_optional_string* carg1, const char * carg2);

SWIGIMPORT void inworld_optional_string_reset(inworld_optional_string* carg1);

SWIGIMPORT char * inworld_optional_string_get(inworld_optional_string* carg1);

SWIGIMPORT const char * inworld_optional_string_getConst(inworld_optional_string* carg1);

SWIGIMPORT char * inworld_optional_string_get_value(inworld_optional_string* carg1);

SWIGIMPORT void inworld_optional_string_set_value(inworld_optional_string* carg1, char * carg2);

SWIGIMPORT inworld_optional_UserContext* inworld_optional_UserContext_new();

SWIGIMPORT inworld_optional_UserContext* inworld_optional_UserContext_new_rcinworld_graphs_UserContext(inworld_UserContext* carg1);

SWIGIMPORT inworld_optional_UserContext* inworld_optional_UserContext_copy(inworld_optional_UserContext* carg1);

SWIGIMPORT void inworld_optional_UserContext_delete(inworld_optional_UserContext* carg1);

SWIGIMPORT bool inworld_optional_UserContext_has_value(inworld_optional_UserContext* carg1);

SWIGIMPORT inworld_UserContext* inworld_optional_UserContext_value(inworld_optional_UserContext* carg1);

SWIGIMPORT inworld_UserContext* inworld_optional_UserContext_valueConst(inworld_optional_UserContext* carg1);

SWIGIMPORT inworld_UserContext* inworld_optional_UserContext_value_or(inworld_optional_UserContext* carg1, inworld_UserContext* carg2);

SWIGIMPORT void inworld_optional_UserContext_reset(inworld_optional_UserContext* carg1);

SWIGIMPORT inworld_UserContext* inworld_optional_UserContext_get(inworld_optional_UserContext* carg1);

SWIGIMPORT inworld_UserContext* inworld_optional_UserContext_getConst(inworld_optional_UserContext* carg1);

SWIGIMPORT inworld_UserContext* inworld_optional_UserContext_get_value(inworld_optional_UserContext* carg1);

SWIGIMPORT void inworld_optional_UserContext_set_value(inworld_optional_UserContext* carg1, inworld_UserContext* carg2);

SWIGIMPORT void inworld_AudioChunk_data_set(inworld_AudioChunk* carg1, inworld_vector_float* carg2);

SWIGIMPORT inworld_vector_float* inworld_AudioChunk_data_get(inworld_AudioChunk* carg1);

SWIGIMPORT void inworld_AudioChunk_sample_rate_set(inworld_AudioChunk* carg1, int carg2);

SWIGIMPORT int inworld_AudioChunk_sample_rate_get(inworld_AudioChunk* carg1);

SWIGIMPORT inworld_AudioChunk* inworld_AudioChunk_new();

SWIGIMPORT inworld_AudioChunk* inworld_AudioChunk_copy(inworld_AudioChunk* carg1);

SWIGIMPORT void inworld_AudioChunk_delete(inworld_AudioChunk* carg1);

SWIGIMPORT inworld_Duration* inworld_Duration_new();

SWIGIMPORT inworld_Duration* inworld_Duration_copy(inworld_Duration* carg1);

SWIGIMPORT void inworld_Duration_delete(inworld_Duration* carg1);

SWIGIMPORT inworld_Duration* inworld_Nanoseconds(int carg1);

SWIGIMPORT inworld_Duration* inworld_Milliseconds(int carg1);

SWIGIMPORT inworld_Duration* inworld_Seconds(int carg1);

SWIGIMPORT inworld_Duration* inworld_Minutes(int carg1);

SWIGIMPORT void inworld_SpeechSynthesisPostprocessingConfig_sample_rate_set(inworld_SpeechSynthesisPostprocessingConfig* carg1, int carg2);

SWIGIMPORT int inworld_SpeechSynthesisPostprocessingConfig_sample_rate_get(inworld_SpeechSynthesisPostprocessingConfig* carg1);

SWIGIMPORT inworld_SpeechSynthesisPostprocessingConfig* inworld_SpeechSynthesisPostprocessingConfig_new();

SWIGIMPORT inworld_SpeechSynthesisPostprocessingConfig* inworld_SpeechSynthesisPostprocessingConfig_copy(inworld_SpeechSynthesisPostprocessingConfig* carg1);

SWIGIMPORT void inworld_SpeechSynthesisPostprocessingConfig_delete(inworld_SpeechSynthesisPostprocessingConfig* carg1);

SWIGIMPORT void inworld_SpeechSynthesisInferenceConfig_temperature_set(inworld_SpeechSynthesisInferenceConfig* carg1, float carg2);

SWIGIMPORT float inworld_SpeechSynthesisInferenceConfig_temperature_get(inworld_SpeechSynthesisInferenceConfig* carg1);

SWIGIMPORT void inworld_SpeechSynthesisInferenceConfig_speaking_rate_set(inworld_SpeechSynthesisInferenceConfig* carg1, float carg2);

SWIGIMPORT float inworld_SpeechSynthesisInferenceConfig_speaking_rate_get(inworld_SpeechSynthesisInferenceConfig* carg1);

SWIGIMPORT inworld_SpeechSynthesisInferenceConfig* inworld_SpeechSynthesisInferenceConfig_new();

SWIGIMPORT inworld_SpeechSynthesisInferenceConfig* inworld_SpeechSynthesisInferenceConfig_copy(inworld_SpeechSynthesisInferenceConfig* carg1);

SWIGIMPORT void inworld_SpeechSynthesisInferenceConfig_delete(inworld_SpeechSynthesisInferenceConfig* carg1);

SWIGIMPORT void inworld_InworldSpeechSynthesisConfig_model_id_set(inworld_InworldSpeechSynthesisConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_InworldSpeechSynthesisConfig_model_id_get(inworld_InworldSpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_InworldSpeechSynthesisConfig_postprocessing_set(inworld_InworldSpeechSynthesisConfig* carg1, inworld_SpeechSynthesisPostprocessingConfig* carg2);

SWIGIMPORT inworld_SpeechSynthesisPostprocessingConfig* inworld_InworldSpeechSynthesisConfig_postprocessing_get(inworld_InworldSpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_InworldSpeechSynthesisConfig_inference_set(inworld_InworldSpeechSynthesisConfig* carg1, inworld_SpeechSynthesisInferenceConfig* carg2);

SWIGIMPORT inworld_SpeechSynthesisInferenceConfig* inworld_InworldSpeechSynthesisConfig_inference_get(inworld_InworldSpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_InworldSpeechSynthesisConfig* inworld_InworldSpeechSynthesisConfig_new();

SWIGIMPORT inworld_InworldSpeechSynthesisConfig* inworld_InworldSpeechSynthesisConfig_copy(inworld_InworldSpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_InworldSpeechSynthesisConfig_delete(inworld_InworldSpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_ElevenLabsSpeechSynthesisConfig_query_params_set(inworld_ElevenLabsSpeechSynthesisConfig* carg1, inworld_QueryParams* carg2);

SWIGIMPORT inworld_QueryParams* inworld_ElevenLabsSpeechSynthesisConfig_query_params_get(inworld_ElevenLabsSpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_ElevenLabsSpeechSynthesisConfig_request_params_set(inworld_ElevenLabsSpeechSynthesisConfig* carg1, inworld_RequestParams* carg2);

SWIGIMPORT inworld_RequestParams* inworld_ElevenLabsSpeechSynthesisConfig_request_params_get(inworld_ElevenLabsSpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_ElevenLabsSpeechSynthesisConfig* inworld_ElevenLabsSpeechSynthesisConfig_new();

SWIGIMPORT inworld_ElevenLabsSpeechSynthesisConfig* inworld_ElevenLabsSpeechSynthesisConfig_copy(inworld_ElevenLabsSpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_ElevenLabsSpeechSynthesisConfig_delete(inworld_ElevenLabsSpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_QueryParams_enable_logging_set(inworld_QueryParams* carg1, bool carg2);

SWIGIMPORT bool inworld_QueryParams_enable_logging_get(inworld_QueryParams* carg1);

SWIGIMPORT void inworld_QueryParams_output_format_set(inworld_QueryParams* carg1, enum inworld_QueryParams_OutputFormat carg2);

SWIGIMPORT enum inworld_QueryParams_OutputFormat inworld_QueryParams_output_format_get(inworld_QueryParams* carg1);

SWIGIMPORT inworld_QueryParams* inworld_QueryParams_new();

SWIGIMPORT inworld_QueryParams* inworld_QueryParams_copy(inworld_QueryParams* carg1);

SWIGIMPORT void inworld_QueryParams_delete(inworld_QueryParams* carg1);

SWIGIMPORT void inworld_RequestParams_model_id_set(inworld_RequestParams* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RequestParams_model_id_get(inworld_RequestParams* carg1);

SWIGIMPORT void inworld_RequestParams_apply_text_normalization_set(inworld_RequestParams* carg1, enum inworld_RequestParams_TextNormalization carg2);

SWIGIMPORT enum inworld_RequestParams_TextNormalization inworld_RequestParams_apply_text_normalization_get(inworld_RequestParams* carg1);

SWIGIMPORT inworld_RequestParams* inworld_RequestParams_new();

SWIGIMPORT inworld_RequestParams* inworld_RequestParams_copy(inworld_RequestParams* carg1);

SWIGIMPORT void inworld_RequestParams_delete(inworld_RequestParams* carg1);

SWIGIMPORT inworld_InworldSpeechSynthesisConfig* inworld_SpeechSynthesisConfig_inworld_config(inworld_SpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_ElevenLabsSpeechSynthesisConfig* inworld_SpeechSynthesisConfig_eleven_labs_config(inworld_SpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_SpeechSynthesisConfig* inworld_SpeechSynthesisConfig_new();

SWIGIMPORT inworld_SpeechSynthesisConfig* inworld_SpeechSynthesisConfig_copy(inworld_SpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_SpeechSynthesisConfig_delete(inworld_SpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_Voice_id_set(inworld_Voice* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Voice_id_get(inworld_Voice* carg1);

SWIGIMPORT void inworld_Voice_language_set(inworld_Voice* carg1, inworld_optional_Language* carg2);

SWIGIMPORT inworld_optional_Language* inworld_Voice_language_get(inworld_Voice* carg1);

SWIGIMPORT inworld_Voice* inworld_Voice_new();

SWIGIMPORT inworld_Voice* inworld_Voice_copy(inworld_Voice* carg1);

SWIGIMPORT void inworld_Voice_delete(inworld_Voice* carg1);

SWIGIMPORT void inworld_TTSInterface_delete(inworld_TTSInterface* carg1);

SWIGIMPORT bool inworld_TTSInterface_is_valid(inworld_TTSInterface* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TTSInterface_SynthesizeSpeech_rcinworld_Voice_rcstd_string(inworld_TTSInterface* carg1, inworld_Voice* carg2, const char * carg3);

SWIGIMPORT inworld_StatusOr_InputStream_AudioChunk* inworld_TTSInterface_SynthesizeSpeech_rcinworld_Voice_rcstd_string_rcinworld_SpeechSynthesisConfig(inworld_TTSInterface* carg1, inworld_Voice* carg2, const char * carg3, inworld_SpeechSynthesisConfig* carg4);

SWIGIMPORT inworld_ModelProperties* inworld_TTSInterface_model_properties(inworld_TTSInterface* carg1);

SWIGIMPORT inworld_optional_Voice* inworld_optional_Voice_new();

SWIGIMPORT inworld_optional_Voice* inworld_optional_Voice_new_rcinworld_Voice(inworld_Voice* carg1);

SWIGIMPORT inworld_optional_Voice* inworld_optional_Voice_copy(inworld_optional_Voice* carg1);

SWIGIMPORT void inworld_optional_Voice_delete(inworld_optional_Voice* carg1);

SWIGIMPORT bool inworld_optional_Voice_has_value(inworld_optional_Voice* carg1);

SWIGIMPORT inworld_Voice* inworld_optional_Voice_value(inworld_optional_Voice* carg1);

SWIGIMPORT inworld_Voice* inworld_optional_Voice_valueConst(inworld_optional_Voice* carg1);

SWIGIMPORT inworld_Voice* inworld_optional_Voice_value_or(inworld_optional_Voice* carg1, inworld_Voice* carg2);

SWIGIMPORT void inworld_optional_Voice_reset(inworld_optional_Voice* carg1);

SWIGIMPORT inworld_Voice* inworld_optional_Voice_get(inworld_optional_Voice* carg1);

SWIGIMPORT inworld_Voice* inworld_optional_Voice_getConst(inworld_optional_Voice* carg1);

SWIGIMPORT inworld_Voice* inworld_optional_Voice_get_value(inworld_optional_Voice* carg1);

SWIGIMPORT void inworld_optional_Voice_set_value(inworld_optional_Voice* carg1, inworld_Voice* carg2);

SWIGIMPORT inworld_optional_TextGenerationConfig* inworld_optional_TextGenerationConfig_new();

SWIGIMPORT inworld_optional_TextGenerationConfig* inworld_optional_TextGenerationConfig_new_rcinworld_TextGenerationConfig(inworld_TextGenerationConfig* carg1);

SWIGIMPORT inworld_optional_TextGenerationConfig* inworld_optional_TextGenerationConfig_copy(inworld_optional_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_optional_TextGenerationConfig_delete(inworld_optional_TextGenerationConfig* carg1);

SWIGIMPORT bool inworld_optional_TextGenerationConfig_has_value(inworld_optional_TextGenerationConfig* carg1);

SWIGIMPORT inworld_TextGenerationConfig* inworld_optional_TextGenerationConfig_value(inworld_optional_TextGenerationConfig* carg1);

SWIGIMPORT inworld_TextGenerationConfig* inworld_optional_TextGenerationConfig_valueConst(inworld_optional_TextGenerationConfig* carg1);

SWIGIMPORT inworld_TextGenerationConfig* inworld_optional_TextGenerationConfig_value_or(inworld_optional_TextGenerationConfig* carg1, inworld_TextGenerationConfig* carg2);

SWIGIMPORT void inworld_optional_TextGenerationConfig_reset(inworld_optional_TextGenerationConfig* carg1);

SWIGIMPORT inworld_TextGenerationConfig* inworld_optional_TextGenerationConfig_get(inworld_optional_TextGenerationConfig* carg1);

SWIGIMPORT inworld_TextGenerationConfig* inworld_optional_TextGenerationConfig_getConst(inworld_optional_TextGenerationConfig* carg1);

SWIGIMPORT inworld_TextGenerationConfig* inworld_optional_TextGenerationConfig_get_value(inworld_optional_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_optional_TextGenerationConfig_set_value(inworld_optional_TextGenerationConfig* carg1, inworld_TextGenerationConfig* carg2);

SWIGIMPORT inworld_optional_ToolChoice* inworld_optional_ToolChoice_new();

SWIGIMPORT inworld_optional_ToolChoice* inworld_optional_ToolChoice_new_rcinworld_ToolChoice(inworld_ToolChoice* carg1);

SWIGIMPORT inworld_optional_ToolChoice* inworld_optional_ToolChoice_copy(inworld_optional_ToolChoice* carg1);

SWIGIMPORT void inworld_optional_ToolChoice_delete(inworld_optional_ToolChoice* carg1);

SWIGIMPORT bool inworld_optional_ToolChoice_has_value(inworld_optional_ToolChoice* carg1);

SWIGIMPORT inworld_ToolChoice* inworld_optional_ToolChoice_value(inworld_optional_ToolChoice* carg1);

SWIGIMPORT inworld_ToolChoice* inworld_optional_ToolChoice_valueConst(inworld_optional_ToolChoice* carg1);

SWIGIMPORT inworld_ToolChoice* inworld_optional_ToolChoice_value_or(inworld_optional_ToolChoice* carg1, inworld_ToolChoice* carg2);

SWIGIMPORT void inworld_optional_ToolChoice_reset(inworld_optional_ToolChoice* carg1);

SWIGIMPORT inworld_ToolChoice* inworld_optional_ToolChoice_get(inworld_optional_ToolChoice* carg1);

SWIGIMPORT inworld_ToolChoice* inworld_optional_ToolChoice_getConst(inworld_optional_ToolChoice* carg1);

SWIGIMPORT inworld_ToolChoice* inworld_optional_ToolChoice_get_value(inworld_optional_ToolChoice* carg1);

SWIGIMPORT void inworld_optional_ToolChoice_set_value(inworld_optional_ToolChoice* carg1, inworld_ToolChoice* carg2);

SWIGIMPORT inworld_Vector_ChatMessage* inworld_Vector_ChatMessage_new();

SWIGIMPORT inworld_Vector_ChatMessage* inworld_Vector_ChatMessage_copy(inworld_Vector_ChatMessage* carg1);

SWIGIMPORT size_t inworld_Vector_ChatMessage_size(inworld_Vector_ChatMessage* carg1);

SWIGIMPORT size_t inworld_Vector_ChatMessage_capacity(inworld_Vector_ChatMessage* carg1);

SWIGIMPORT void inworld_Vector_ChatMessage_reserve(inworld_Vector_ChatMessage* carg1, size_t carg2);

SWIGIMPORT bool inworld_Vector_ChatMessage_empty(inworld_Vector_ChatMessage* carg1);

SWIGIMPORT void inworld_Vector_ChatMessage_clear(inworld_Vector_ChatMessage* carg1);

SWIGIMPORT void inworld_Vector_ChatMessage_push_back(inworld_Vector_ChatMessage* carg1, inworld_ChatMessage* carg2);

SWIGIMPORT inworld_ChatMessage* inworld_Vector_ChatMessage_get(inworld_Vector_ChatMessage* carg1, int carg2);

SWIGIMPORT void inworld_Vector_ChatMessage_set(inworld_Vector_ChatMessage* carg1, int carg2, inworld_ChatMessage* carg3);

SWIGIMPORT void inworld_Vector_ChatMessage_delete(inworld_Vector_ChatMessage* carg1);

SWIGIMPORT inworld_Vector_Tool* inworld_Vector_Tool_new();

SWIGIMPORT inworld_Vector_Tool* inworld_Vector_Tool_copy(inworld_Vector_Tool* carg1);

SWIGIMPORT size_t inworld_Vector_Tool_size(inworld_Vector_Tool* carg1);

SWIGIMPORT size_t inworld_Vector_Tool_capacity(inworld_Vector_Tool* carg1);

SWIGIMPORT void inworld_Vector_Tool_reserve(inworld_Vector_Tool* carg1, size_t carg2);

SWIGIMPORT bool inworld_Vector_Tool_empty(inworld_Vector_Tool* carg1);

SWIGIMPORT void inworld_Vector_Tool_clear(inworld_Vector_Tool* carg1);

SWIGIMPORT void inworld_Vector_Tool_push_back(inworld_Vector_Tool* carg1, inworld_Tool* carg2);

SWIGIMPORT inworld_Tool* inworld_Vector_Tool_get(inworld_Vector_Tool* carg1, int carg2);

SWIGIMPORT void inworld_Vector_Tool_set(inworld_Vector_Tool* carg1, int carg2, inworld_Tool* carg3);

SWIGIMPORT void inworld_Vector_Tool_delete(inworld_Vector_Tool* carg1);

SWIGIMPORT inworld_optional_vector_ChatMessage* inworld_optional_vector_ChatMessage_new();

SWIGIMPORT inworld_optional_vector_ChatMessage* inworld_optional_vector_ChatMessage_new_rcstd_vector_Sl_inworld_graphs_ChatMessage_Sg_(inworld_Vector_ChatMessage* carg1);

SWIGIMPORT inworld_optional_vector_ChatMessage* inworld_optional_vector_ChatMessage_copy(inworld_optional_vector_ChatMessage* carg1);

SWIGIMPORT void inworld_optional_vector_ChatMessage_delete(inworld_optional_vector_ChatMessage* carg1);

SWIGIMPORT bool inworld_optional_vector_ChatMessage_has_value(inworld_optional_vector_ChatMessage* carg1);

SWIGIMPORT inworld_Vector_ChatMessage* inworld_optional_vector_ChatMessage_value(inworld_optional_vector_ChatMessage* carg1);

SWIGIMPORT inworld_Vector_ChatMessage* inworld_optional_vector_ChatMessage_valueConst(inworld_optional_vector_ChatMessage* carg1);

SWIGIMPORT inworld_Vector_ChatMessage* inworld_optional_vector_ChatMessage_value_or(inworld_optional_vector_ChatMessage* carg1, inworld_Vector_ChatMessage* carg2);

SWIGIMPORT void inworld_optional_vector_ChatMessage_reset(inworld_optional_vector_ChatMessage* carg1);

SWIGIMPORT inworld_Vector_ChatMessage* inworld_optional_vector_ChatMessage_get(inworld_optional_vector_ChatMessage* carg1);

SWIGIMPORT inworld_Vector_ChatMessage* inworld_optional_vector_ChatMessage_getConst(inworld_optional_vector_ChatMessage* carg1);

SWIGIMPORT inworld_Vector_ChatMessage* inworld_optional_vector_ChatMessage_get_value(inworld_optional_vector_ChatMessage* carg1);

SWIGIMPORT void inworld_optional_vector_ChatMessage_set_value(inworld_optional_vector_ChatMessage* carg1, inworld_Vector_ChatMessage* carg2);

SWIGIMPORT inworld_optional_vector_Tool* inworld_optional_vector_Tool_new();

SWIGIMPORT inworld_optional_vector_Tool* inworld_optional_vector_Tool_new_rcstd_vector_Sl_inworld_Tool_Sg_(inworld_Vector_Tool* carg1);

SWIGIMPORT inworld_optional_vector_Tool* inworld_optional_vector_Tool_copy(inworld_optional_vector_Tool* carg1);

SWIGIMPORT void inworld_optional_vector_Tool_delete(inworld_optional_vector_Tool* carg1);

SWIGIMPORT bool inworld_optional_vector_Tool_has_value(inworld_optional_vector_Tool* carg1);

SWIGIMPORT inworld_Vector_Tool* inworld_optional_vector_Tool_value(inworld_optional_vector_Tool* carg1);

SWIGIMPORT inworld_Vector_Tool* inworld_optional_vector_Tool_valueConst(inworld_optional_vector_Tool* carg1);

SWIGIMPORT inworld_Vector_Tool* inworld_optional_vector_Tool_value_or(inworld_optional_vector_Tool* carg1, inworld_Vector_Tool* carg2);

SWIGIMPORT void inworld_optional_vector_Tool_reset(inworld_optional_vector_Tool* carg1);

SWIGIMPORT inworld_Vector_Tool* inworld_optional_vector_Tool_get(inworld_optional_vector_Tool* carg1);

SWIGIMPORT inworld_Vector_Tool* inworld_optional_vector_Tool_getConst(inworld_optional_vector_Tool* carg1);

SWIGIMPORT inworld_Vector_Tool* inworld_optional_vector_Tool_get_value(inworld_optional_vector_Tool* carg1);

SWIGIMPORT void inworld_optional_vector_Tool_set_value(inworld_optional_vector_Tool* carg1, inworld_Vector_Tool* carg2);

SWIGIMPORT void inworld_SpeechRecognitionConfig_language_set(inworld_SpeechRecognitionConfig* carg1, inworld_optional_Language* carg2);

SWIGIMPORT inworld_optional_Language* inworld_SpeechRecognitionConfig_language_get(inworld_SpeechRecognitionConfig* carg1);

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_SpeechRecognitionConfig_new();

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_SpeechRecognitionConfig_copy(inworld_SpeechRecognitionConfig* carg1);

SWIGIMPORT void inworld_SpeechRecognitionConfig_delete(inworld_SpeechRecognitionConfig* carg1);

SWIGIMPORT void inworld_STTInterface_delete(inworld_STTInterface* carg1);

SWIGIMPORT bool inworld_STTInterface_is_valid(inworld_STTInterface* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_string* inworld_STTInterface_RecognizeSpeech(inworld_STTInterface* carg1, inworld_AudioChunk* carg2, inworld_SpeechRecognitionConfig* carg3);

SWIGIMPORT inworld_ModelProperties* inworld_STTInterface_model_properties(inworld_STTInterface* carg1);

SWIGIMPORT inworld_optional_SpeechSynthesisConfig* inworld_optional_SpeechSynthesisConfig_new();

SWIGIMPORT inworld_optional_SpeechSynthesisConfig* inworld_optional_SpeechSynthesisConfig_new_rcinworld_SpeechSynthesisConfig(inworld_SpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_optional_SpeechSynthesisConfig* inworld_optional_SpeechSynthesisConfig_copy(inworld_optional_SpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_optional_SpeechSynthesisConfig_delete(inworld_optional_SpeechSynthesisConfig* carg1);

SWIGIMPORT bool inworld_optional_SpeechSynthesisConfig_has_value(inworld_optional_SpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_SpeechSynthesisConfig* inworld_optional_SpeechSynthesisConfig_value(inworld_optional_SpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_SpeechSynthesisConfig* inworld_optional_SpeechSynthesisConfig_valueConst(inworld_optional_SpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_SpeechSynthesisConfig* inworld_optional_SpeechSynthesisConfig_value_or(inworld_optional_SpeechSynthesisConfig* carg1, inworld_SpeechSynthesisConfig* carg2);

SWIGIMPORT void inworld_optional_SpeechSynthesisConfig_reset(inworld_optional_SpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_SpeechSynthesisConfig* inworld_optional_SpeechSynthesisConfig_get(inworld_optional_SpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_SpeechSynthesisConfig* inworld_optional_SpeechSynthesisConfig_getConst(inworld_optional_SpeechSynthesisConfig* carg1);

SWIGIMPORT inworld_SpeechSynthesisConfig* inworld_optional_SpeechSynthesisConfig_get_value(inworld_optional_SpeechSynthesisConfig* carg1);

SWIGIMPORT void inworld_optional_SpeechSynthesisConfig_set_value(inworld_optional_SpeechSynthesisConfig* carg1, inworld_SpeechSynthesisConfig* carg2);

SWIGIMPORT inworld_optional_SpeechRecognitionConfig* inworld_optional_SpeechRecognitionConfig_new();

SWIGIMPORT inworld_optional_SpeechRecognitionConfig* inworld_optional_SpeechRecognitionConfig_new_rcinworld_SpeechRecognitionConfig(inworld_SpeechRecognitionConfig* carg1);

SWIGIMPORT inworld_optional_SpeechRecognitionConfig* inworld_optional_SpeechRecognitionConfig_copy(inworld_optional_SpeechRecognitionConfig* carg1);

SWIGIMPORT void inworld_optional_SpeechRecognitionConfig_delete(inworld_optional_SpeechRecognitionConfig* carg1);

SWIGIMPORT bool inworld_optional_SpeechRecognitionConfig_has_value(inworld_optional_SpeechRecognitionConfig* carg1);

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_optional_SpeechRecognitionConfig_value(inworld_optional_SpeechRecognitionConfig* carg1);

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_optional_SpeechRecognitionConfig_valueConst(inworld_optional_SpeechRecognitionConfig* carg1);

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_optional_SpeechRecognitionConfig_value_or(inworld_optional_SpeechRecognitionConfig* carg1, inworld_SpeechRecognitionConfig* carg2);

SWIGIMPORT void inworld_optional_SpeechRecognitionConfig_reset(inworld_optional_SpeechRecognitionConfig* carg1);

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_optional_SpeechRecognitionConfig_get(inworld_optional_SpeechRecognitionConfig* carg1);

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_optional_SpeechRecognitionConfig_getConst(inworld_optional_SpeechRecognitionConfig* carg1);

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_optional_SpeechRecognitionConfig_get_value(inworld_optional_SpeechRecognitionConfig* carg1);

SWIGIMPORT void inworld_optional_SpeechRecognitionConfig_set_value(inworld_optional_SpeechRecognitionConfig* carg1, inworld_SpeechRecognitionConfig* carg2);

SWIGIMPORT inworld_optional_TextClassifierConfig* inworld_optional_TextClassifierConfig_new();

SWIGIMPORT inworld_optional_TextClassifierConfig* inworld_optional_TextClassifierConfig_new_rcinworld_TextClassifierConfig(inworld_TextClassifierConfig* carg1);

SWIGIMPORT inworld_optional_TextClassifierConfig* inworld_optional_TextClassifierConfig_copy(inworld_optional_TextClassifierConfig* carg1);

SWIGIMPORT void inworld_optional_TextClassifierConfig_delete(inworld_optional_TextClassifierConfig* carg1);

SWIGIMPORT bool inworld_optional_TextClassifierConfig_has_value(inworld_optional_TextClassifierConfig* carg1);

SWIGIMPORT inworld_TextClassifierConfig* inworld_optional_TextClassifierConfig_value(inworld_optional_TextClassifierConfig* carg1);

SWIGIMPORT inworld_TextClassifierConfig* inworld_optional_TextClassifierConfig_valueConst(inworld_optional_TextClassifierConfig* carg1);

SWIGIMPORT inworld_TextClassifierConfig* inworld_optional_TextClassifierConfig_value_or(inworld_optional_TextClassifierConfig* carg1, inworld_TextClassifierConfig* carg2);

SWIGIMPORT void inworld_optional_TextClassifierConfig_reset(inworld_optional_TextClassifierConfig* carg1);

SWIGIMPORT inworld_TextClassifierConfig* inworld_optional_TextClassifierConfig_get(inworld_optional_TextClassifierConfig* carg1);

SWIGIMPORT inworld_TextClassifierConfig* inworld_optional_TextClassifierConfig_getConst(inworld_optional_TextClassifierConfig* carg1);

SWIGIMPORT inworld_TextClassifierConfig* inworld_optional_TextClassifierConfig_get_value(inworld_optional_TextClassifierConfig* carg1);

SWIGIMPORT void inworld_optional_TextClassifierConfig_set_value(inworld_optional_TextClassifierConfig* carg1, inworld_TextClassifierConfig* carg2);

SWIGIMPORT inworld_LogitBiasVector* inworld_LogitBiasVector_new();

SWIGIMPORT inworld_LogitBiasVector* inworld_LogitBiasVector_copy(inworld_LogitBiasVector* carg1);

SWIGIMPORT size_t inworld_LogitBiasVector_size(inworld_LogitBiasVector* carg1);

SWIGIMPORT size_t inworld_LogitBiasVector_capacity(inworld_LogitBiasVector* carg1);

SWIGIMPORT void inworld_LogitBiasVector_reserve(inworld_LogitBiasVector* carg1, size_t carg2);

SWIGIMPORT bool inworld_LogitBiasVector_empty(inworld_LogitBiasVector* carg1);

SWIGIMPORT void inworld_LogitBiasVector_clear(inworld_LogitBiasVector* carg1);

SWIGIMPORT void inworld_LogitBiasVector_push_back(inworld_LogitBiasVector* carg1, inworld_LogitBias* carg2);

SWIGIMPORT inworld_LogitBias* inworld_LogitBiasVector_get(inworld_LogitBiasVector* carg1, int carg2);

SWIGIMPORT void inworld_LogitBiasVector_set(inworld_LogitBiasVector* carg1, int carg2, inworld_LogitBias* carg3);

SWIGIMPORT void inworld_LogitBiasVector_delete(inworld_LogitBiasVector* carg1);

SWIGIMPORT inworld_StatusOr_Tools* inworld_StatusOr_Tools_new();

SWIGIMPORT inworld_StatusOr_Tools* inworld_StatusOr_Tools_new_rcstd_vector_Sl_inworld_Tool_Sg_(inworld_Vector_Tool* carg1);

SWIGIMPORT inworld_StatusOr_Tools* inworld_StatusOr_Tools_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_Tools_ok(inworld_StatusOr_Tools* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_Tools_status(inworld_StatusOr_Tools* carg1);

SWIGIMPORT inworld_Vector_Tool* inworld_StatusOr_Tools_value(inworld_StatusOr_Tools* carg1);

SWIGIMPORT inworld_StatusOr_Tools* inworld_StatusOr_Tools_copy(inworld_StatusOr_Tools* carg1);

SWIGIMPORT void inworld_StatusOr_Tools_delete(inworld_StatusOr_Tools* carg1);

SWIGIMPORT inworld_Messages* inworld_Messages_new();

SWIGIMPORT inworld_Messages* inworld_Messages_copy(inworld_Messages* carg1);

SWIGIMPORT size_t inworld_Messages_size(inworld_Messages* carg1);

SWIGIMPORT size_t inworld_Messages_capacity(inworld_Messages* carg1);

SWIGIMPORT void inworld_Messages_reserve(inworld_Messages* carg1, size_t carg2);

SWIGIMPORT bool inworld_Messages_empty(inworld_Messages* carg1);

SWIGIMPORT void inworld_Messages_clear(inworld_Messages* carg1);

SWIGIMPORT void inworld_Messages_push_back(inworld_Messages* carg1, inworld_Message* carg2);

SWIGIMPORT inworld_Message* inworld_Messages_get(inworld_Messages* carg1, int carg2);

SWIGIMPORT void inworld_Messages_set(inworld_Messages* carg1, int carg2, inworld_Message* carg3);

SWIGIMPORT void inworld_Messages_delete(inworld_Messages* carg1);

SWIGIMPORT inworld_ToolCalls* inworld_ToolCalls_new();

SWIGIMPORT inworld_ToolCalls* inworld_ToolCalls_copy(inworld_ToolCalls* carg1);

SWIGIMPORT size_t inworld_ToolCalls_size(inworld_ToolCalls* carg1);

SWIGIMPORT size_t inworld_ToolCalls_capacity(inworld_ToolCalls* carg1);

SWIGIMPORT void inworld_ToolCalls_reserve(inworld_ToolCalls* carg1, size_t carg2);

SWIGIMPORT bool inworld_ToolCalls_empty(inworld_ToolCalls* carg1);

SWIGIMPORT void inworld_ToolCalls_clear(inworld_ToolCalls* carg1);

SWIGIMPORT void inworld_ToolCalls_push_back(inworld_ToolCalls* carg1, inworld_ToolCall* carg2);

SWIGIMPORT inworld_ToolCall* inworld_ToolCalls_get(inworld_ToolCalls* carg1, int carg2);

SWIGIMPORT void inworld_ToolCalls_set(inworld_ToolCalls* carg1, int carg2, inworld_ToolCall* carg3);

SWIGIMPORT void inworld_ToolCalls_delete(inworld_ToolCalls* carg1);

SWIGIMPORT inworld_ContentItems* inworld_ContentItems_new();

SWIGIMPORT inworld_ContentItems* inworld_ContentItems_copy(inworld_ContentItems* carg1);

SWIGIMPORT size_t inworld_ContentItems_size(inworld_ContentItems* carg1);

SWIGIMPORT size_t inworld_ContentItems_capacity(inworld_ContentItems* carg1);

SWIGIMPORT void inworld_ContentItems_reserve(inworld_ContentItems* carg1, size_t carg2);

SWIGIMPORT bool inworld_ContentItems_empty(inworld_ContentItems* carg1);

SWIGIMPORT void inworld_ContentItems_clear(inworld_ContentItems* carg1);

SWIGIMPORT void inworld_ContentItems_push_back(inworld_ContentItems* carg1, inworld_ContentItem* carg2);

SWIGIMPORT inworld_ContentItem* inworld_ContentItems_get(inworld_ContentItems* carg1, int carg2);

SWIGIMPORT void inworld_ContentItems_set(inworld_ContentItems* carg1, int carg2, inworld_ContentItem* carg3);

SWIGIMPORT void inworld_ContentItems_delete(inworld_ContentItems* carg1);

SWIGIMPORT void inworld_LogitBias_token_id_set(inworld_LogitBias* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LogitBias_token_id_get(inworld_LogitBias* carg1);

SWIGIMPORT void inworld_LogitBias_bias_value_set(inworld_LogitBias* carg1, int carg2);

SWIGIMPORT int inworld_LogitBias_bias_value_get(inworld_LogitBias* carg1);

SWIGIMPORT inworld_LogitBias* inworld_LogitBias_new();

SWIGIMPORT inworld_LogitBias* inworld_LogitBias_copy(inworld_LogitBias* carg1);

SWIGIMPORT void inworld_LogitBias_delete(inworld_LogitBias* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_max_new_tokens_set(inworld_TextGenerationConfig* carg1, int carg2);

SWIGIMPORT int inworld_TextGenerationConfig_max_new_tokens_get(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_max_prompt_length_set(inworld_TextGenerationConfig* carg1, int carg2);

SWIGIMPORT int inworld_TextGenerationConfig_max_prompt_length_get(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_temperature_set(inworld_TextGenerationConfig* carg1, float carg2);

SWIGIMPORT float inworld_TextGenerationConfig_temperature_get(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_top_p_set(inworld_TextGenerationConfig* carg1, float carg2);

SWIGIMPORT float inworld_TextGenerationConfig_top_p_get(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_repetition_penalty_set(inworld_TextGenerationConfig* carg1, float carg2);

SWIGIMPORT float inworld_TextGenerationConfig_repetition_penalty_get(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_frequency_penalty_set(inworld_TextGenerationConfig* carg1, float carg2);

SWIGIMPORT float inworld_TextGenerationConfig_frequency_penalty_get(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_presence_penalty_set(inworld_TextGenerationConfig* carg1, float carg2);

SWIGIMPORT float inworld_TextGenerationConfig_presence_penalty_get(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_stop_sequences_set(inworld_TextGenerationConfig* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_TextGenerationConfig_stop_sequences_get(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_seed_set(inworld_TextGenerationConfig* carg1, inworld_optional_int* carg2);

SWIGIMPORT inworld_optional_int* inworld_TextGenerationConfig_seed_get(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_logit_bias_set(inworld_TextGenerationConfig* carg1, inworld_LogitBiasVector* carg2);

SWIGIMPORT inworld_LogitBiasVector* inworld_TextGenerationConfig_logit_bias_get(inworld_TextGenerationConfig* carg1);

SWIGIMPORT bool inworld_TextGenerationConfig_HasSeed(inworld_TextGenerationConfig* carg1);

SWIGIMPORT int inworld_TextGenerationConfig_GetSeed(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_SetSeed(inworld_TextGenerationConfig* carg1, int carg2);

SWIGIMPORT void inworld_TextGenerationConfig_ClearSeed(inworld_TextGenerationConfig* carg1);

SWIGIMPORT inworld_TextGenerationConfig* inworld_TextGenerationConfig_new();

SWIGIMPORT inworld_TextGenerationConfig* inworld_TextGenerationConfig_copy(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_TextGenerationConfig_delete(inworld_TextGenerationConfig* carg1);

SWIGIMPORT void inworld_Tool_name_set(inworld_Tool* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Tool_name_get(inworld_Tool* carg1);

SWIGIMPORT void inworld_Tool_description_set(inworld_Tool* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Tool_description_get(inworld_Tool* carg1);

SWIGIMPORT void inworld_Tool_SetPropertiesFromString(inworld_Tool* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Tool_GetPropertiesAsString(inworld_Tool* carg1);

SWIGIMPORT inworld_Tool* inworld_Tool_new();

SWIGIMPORT inworld_Tool* inworld_Tool_copy(inworld_Tool* carg1);

SWIGIMPORT void inworld_Tool_delete(inworld_Tool* carg1);

SWIGIMPORT void inworld_FunctionChoice_type_set(inworld_FunctionChoice* carg1, const char * carg2);

SWIGIMPORT const char * inworld_FunctionChoice_type_get(inworld_FunctionChoice* carg1);

SWIGIMPORT void inworld_FunctionChoice_name_set(inworld_FunctionChoice* carg1, const char * carg2);

SWIGIMPORT const char * inworld_FunctionChoice_name_get(inworld_FunctionChoice* carg1);

SWIGIMPORT inworld_FunctionChoice* inworld_FunctionChoice_new();

SWIGIMPORT inworld_FunctionChoice* inworld_FunctionChoice_copy(inworld_FunctionChoice* carg1);

SWIGIMPORT void inworld_FunctionChoice_delete(inworld_FunctionChoice* carg1);

SWIGIMPORT bool inworld_ToolChoice_IsStringChoice(inworld_ToolChoice* carg1);

SWIGIMPORT bool inworld_ToolChoice_IsFunctionChoice(inworld_ToolChoice* carg1);

SWIGIMPORT const char * inworld_ToolChoice_GetStringChoice(inworld_ToolChoice* carg1);

SWIGIMPORT inworld_FunctionChoice* inworld_ToolChoice_GetFunctionChoice(inworld_ToolChoice* carg1);

SWIGIMPORT void inworld_ToolChoice_SetStringChoice(inworld_ToolChoice* carg1, const char * carg2);

SWIGIMPORT void inworld_ToolChoice_SetFunctionChoice(inworld_ToolChoice* carg1, inworld_FunctionChoice* carg2);

SWIGIMPORT inworld_ToolChoice* inworld_ToolChoice_new();

SWIGIMPORT inworld_ToolChoice* inworld_ToolChoice_copy(inworld_ToolChoice* carg1);

SWIGIMPORT void inworld_ToolChoice_delete(inworld_ToolChoice* carg1);

SWIGIMPORT void inworld_ToolCall_id_set(inworld_ToolCall* carg1, const char * carg2);

SWIGIMPORT const char * inworld_ToolCall_id_get(inworld_ToolCall* carg1);

SWIGIMPORT void inworld_ToolCall_name_set(inworld_ToolCall* carg1, const char * carg2);

SWIGIMPORT const char * inworld_ToolCall_name_get(inworld_ToolCall* carg1);

SWIGIMPORT void inworld_ToolCall_args_set(inworld_ToolCall* carg1, const char * carg2);

SWIGIMPORT const char * inworld_ToolCall_args_get(inworld_ToolCall* carg1);

SWIGIMPORT inworld_ToolCall* inworld_ToolCall_new();

SWIGIMPORT inworld_ToolCall* inworld_ToolCall_copy(inworld_ToolCall* carg1);

SWIGIMPORT void inworld_ToolCall_delete(inworld_ToolCall* carg1);

SWIGIMPORT void inworld_ImageUrl_url_set(inworld_ImageUrl* carg1, const char * carg2);

SWIGIMPORT const char * inworld_ImageUrl_url_get(inworld_ImageUrl* carg1);

SWIGIMPORT void inworld_ImageUrl_detail_set(inworld_ImageUrl* carg1, const char * carg2);

SWIGIMPORT const char * inworld_ImageUrl_detail_get(inworld_ImageUrl* carg1);

SWIGIMPORT inworld_ImageUrl* inworld_ImageUrl_new();

SWIGIMPORT inworld_ImageUrl* inworld_ImageUrl_copy(inworld_ImageUrl* carg1);

SWIGIMPORT void inworld_ImageUrl_delete(inworld_ImageUrl* carg1);

SWIGIMPORT bool inworld_ContentItem_IsText(inworld_ContentItem* carg1);

SWIGIMPORT bool inworld_ContentItem_IsImage(inworld_ContentItem* carg1);

SWIGIMPORT const char * inworld_ContentItem_GetText(inworld_ContentItem* carg1);

SWIGIMPORT inworld_ImageUrl* inworld_ContentItem_GetImageUrl(inworld_ContentItem* carg1);

SWIGIMPORT void inworld_ContentItem_SetText(inworld_ContentItem* carg1, const char * carg2);

SWIGIMPORT void inworld_ContentItem_SetImageUrl(inworld_ContentItem* carg1, inworld_ImageUrl* carg2);

SWIGIMPORT inworld_ContentItem* inworld_ContentItem_new();

SWIGIMPORT inworld_ContentItem* inworld_ContentItem_copy(inworld_ContentItem* carg1);

SWIGIMPORT void inworld_ContentItem_delete(inworld_ContentItem* carg1);

SWIGIMPORT void inworld_Message_role_set(inworld_Message* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Message_role_get(inworld_Message* carg1);

SWIGIMPORT void inworld_Message_tool_calls_set(inworld_Message* carg1, inworld_ToolCalls* carg2);

SWIGIMPORT inworld_ToolCalls* inworld_Message_tool_calls_get(inworld_Message* carg1);

SWIGIMPORT void inworld_Message_tool_call_id_set(inworld_Message* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Message_tool_call_id_get(inworld_Message* carg1);

SWIGIMPORT bool inworld_Message_IsTextContent(inworld_Message* carg1);

SWIGIMPORT bool inworld_Message_IsMultimodalContent(inworld_Message* carg1);

SWIGIMPORT const char * inworld_Message_GetTextContent(inworld_Message* carg1);

SWIGIMPORT inworld_ContentItems* inworld_Message_GetContentItems(inworld_Message* carg1);

SWIGIMPORT void inworld_Message_SetTextContent(inworld_Message* carg1, const char * carg2);

SWIGIMPORT void inworld_Message_SetContentItems(inworld_Message* carg1, inworld_ContentItems* carg2);

SWIGIMPORT inworld_Message* inworld_Message_new();

SWIGIMPORT inworld_Message* inworld_Message_copy(inworld_Message* carg1);

SWIGIMPORT void inworld_Message_delete(inworld_Message* carg1);

SWIGIMPORT void inworld_Content_content_set(inworld_Content* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Content_content_get(inworld_Content* carg1);

SWIGIMPORT void inworld_Content_tool_calls_set(inworld_Content* carg1, inworld_ToolCalls* carg2);

SWIGIMPORT inworld_ToolCalls* inworld_Content_tool_calls_get(inworld_Content* carg1);

SWIGIMPORT inworld_Content* inworld_Content_new();

SWIGIMPORT inworld_Content* inworld_Content_copy(inworld_Content* carg1);

SWIGIMPORT void inworld_Content_delete(inworld_Content* carg1);

SWIGIMPORT void inworld_LLMInterface_delete(inworld_LLMInterface* carg1);

SWIGIMPORT bool inworld_LLMInterface_is_valid(inworld_LLMInterface* carg1);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_LLMInterface_GenerateContent_rcstd_string(inworld_LLMInterface* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_LLMInterface_GenerateContent_rcstd_string_rcinworld_TextGenerationConfig(inworld_LLMInterface* carg1, const char * carg2, inworld_TextGenerationConfig* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_LLMInterface_GenerateContent_rcstd_vector_Sl_inworld_Message_Sg__rcinworld_TextGenerationConfig(inworld_LLMInterface* carg1, inworld_Messages* carg2, inworld_TextGenerationConfig* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_LLMInterface_GenerateContent_rcstd_vector_Sl_inworld_Message_Sg__rcstd_vector_Sl_inworld_Tool_Sg_(inworld_LLMInterface* carg1, inworld_Messages* carg2, inworld_Vector_Tool* carg3);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_LLMInterface_GenerateContent_rcstd_vector_Sl_inworld_Message_Sg__rcinworld_TextGenerationConfig_rcstd_vector_Sl_inworld_Tool_Sg_(inworld_LLMInterface* carg1, inworld_Messages* carg2, inworld_TextGenerationConfig* carg3, inworld_Vector_Tool* carg4);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_LLMInterface_GenerateContent_rcstd_vector_Sl_inworld_Message_Sg__rcstd_vector_Sl_inworld_Tool_Sg__rcinworld_ToolChoice(inworld_LLMInterface* carg1, inworld_Messages* carg2, inworld_Vector_Tool* carg3, inworld_ToolChoice* carg4);

SWIGIMPORT inworld_StatusOr_InputStream_Content* inworld_LLMInterface_GenerateContent_rcstd_vector_Sl_inworld_Message_Sg__rcinworld_TextGenerationConfig_rcstd_vector_Sl_inworld_Tool_Sg__rcinworld_ToolChoice(inworld_LLMInterface* carg1, inworld_Messages* carg2, inworld_TextGenerationConfig* carg3, inworld_Vector_Tool* carg4, inworld_ToolChoice* carg5);

SWIGIMPORT inworld_ModelProperties* inworld_LLMInterface_model_properties(inworld_LLMInterface* carg1);

SWIGIMPORT inworld_optional_LocalLLMConfig* inworld_optional_LocalLLMConfig_new();

SWIGIMPORT inworld_optional_LocalLLMConfig* inworld_optional_LocalLLMConfig_new_rcinworld_LocalLLMConfig(inworld_LocalLLMConfig* carg1);

SWIGIMPORT inworld_optional_LocalLLMConfig* inworld_optional_LocalLLMConfig_copy(inworld_optional_LocalLLMConfig* carg1);

SWIGIMPORT void inworld_optional_LocalLLMConfig_delete(inworld_optional_LocalLLMConfig* carg1);

SWIGIMPORT bool inworld_optional_LocalLLMConfig_has_value(inworld_optional_LocalLLMConfig* carg1);

SWIGIMPORT inworld_LocalLLMConfig* inworld_optional_LocalLLMConfig_value(inworld_optional_LocalLLMConfig* carg1);

SWIGIMPORT inworld_LocalLLMConfig* inworld_optional_LocalLLMConfig_valueConst(inworld_optional_LocalLLMConfig* carg1);

SWIGIMPORT inworld_LocalLLMConfig* inworld_optional_LocalLLMConfig_value_or(inworld_optional_LocalLLMConfig* carg1, inworld_LocalLLMConfig* carg2);

SWIGIMPORT void inworld_optional_LocalLLMConfig_reset(inworld_optional_LocalLLMConfig* carg1);

SWIGIMPORT inworld_LocalLLMConfig* inworld_optional_LocalLLMConfig_get(inworld_optional_LocalLLMConfig* carg1);

SWIGIMPORT inworld_LocalLLMConfig* inworld_optional_LocalLLMConfig_getConst(inworld_optional_LocalLLMConfig* carg1);

SWIGIMPORT inworld_LocalLLMConfig* inworld_optional_LocalLLMConfig_get_value(inworld_optional_LocalLLMConfig* carg1);

SWIGIMPORT void inworld_optional_LocalLLMConfig_set_value(inworld_optional_LocalLLMConfig* carg1, inworld_LocalLLMConfig* carg2);

SWIGIMPORT inworld_optional_RemoteLLMConfig* inworld_optional_RemoteLLMConfig_new();

SWIGIMPORT inworld_optional_RemoteLLMConfig* inworld_optional_RemoteLLMConfig_new_rcinworld_RemoteLLMConfig(inworld_RemoteLLMConfig* carg1);

SWIGIMPORT inworld_optional_RemoteLLMConfig* inworld_optional_RemoteLLMConfig_copy(inworld_optional_RemoteLLMConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteLLMConfig_delete(inworld_optional_RemoteLLMConfig* carg1);

SWIGIMPORT bool inworld_optional_RemoteLLMConfig_has_value(inworld_optional_RemoteLLMConfig* carg1);

SWIGIMPORT inworld_RemoteLLMConfig* inworld_optional_RemoteLLMConfig_value(inworld_optional_RemoteLLMConfig* carg1);

SWIGIMPORT inworld_RemoteLLMConfig* inworld_optional_RemoteLLMConfig_valueConst(inworld_optional_RemoteLLMConfig* carg1);

SWIGIMPORT inworld_RemoteLLMConfig* inworld_optional_RemoteLLMConfig_value_or(inworld_optional_RemoteLLMConfig* carg1, inworld_RemoteLLMConfig* carg2);

SWIGIMPORT void inworld_optional_RemoteLLMConfig_reset(inworld_optional_RemoteLLMConfig* carg1);

SWIGIMPORT inworld_RemoteLLMConfig* inworld_optional_RemoteLLMConfig_get(inworld_optional_RemoteLLMConfig* carg1);

SWIGIMPORT inworld_RemoteLLMConfig* inworld_optional_RemoteLLMConfig_getConst(inworld_optional_RemoteLLMConfig* carg1);

SWIGIMPORT inworld_RemoteLLMConfig* inworld_optional_RemoteLLMConfig_get_value(inworld_optional_RemoteLLMConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteLLMConfig_set_value(inworld_optional_RemoteLLMConfig* carg1, inworld_RemoteLLMConfig* carg2);

SWIGIMPORT void inworld_LocalLLMConfig_model_path_set(inworld_LocalLLMConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LocalLLMConfig_model_path_get(inworld_LocalLLMConfig* carg1);

SWIGIMPORT void inworld_LocalLLMConfig_device_set(inworld_LocalLLMConfig* carg1, inworld_Device* carg2);

SWIGIMPORT inworld_Device* inworld_LocalLLMConfig_device_get(inworld_LocalLLMConfig* carg1);

SWIGIMPORT void inworld_LocalLLMConfig_default_config_set(inworld_LocalLLMConfig* carg1, inworld_TextGenerationConfig* carg2);

SWIGIMPORT inworld_TextGenerationConfig* inworld_LocalLLMConfig_default_config_get(inworld_LocalLLMConfig* carg1);

SWIGIMPORT inworld_LocalLLMConfig* inworld_LocalLLMConfig_new();

SWIGIMPORT inworld_LocalLLMConfig* inworld_LocalLLMConfig_copy(inworld_LocalLLMConfig* carg1);

SWIGIMPORT void inworld_LocalLLMConfig_delete(inworld_LocalLLMConfig* carg1);

SWIGIMPORT void inworld_RemoteLLMConfig_provider_set(inworld_RemoteLLMConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RemoteLLMConfig_provider_get(inworld_RemoteLLMConfig* carg1);

SWIGIMPORT void inworld_RemoteLLMConfig_model_name_set(inworld_RemoteLLMConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RemoteLLMConfig_model_name_get(inworld_RemoteLLMConfig* carg1);

SWIGIMPORT void inworld_RemoteLLMConfig_api_key_set(inworld_RemoteLLMConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RemoteLLMConfig_api_key_get(inworld_RemoteLLMConfig* carg1);

SWIGIMPORT void inworld_RemoteLLMConfig_default_config_set(inworld_RemoteLLMConfig* carg1, inworld_TextGenerationConfig* carg2);

SWIGIMPORT inworld_TextGenerationConfig* inworld_RemoteLLMConfig_default_config_get(inworld_RemoteLLMConfig* carg1);

SWIGIMPORT inworld_RemoteLLMConfig* inworld_RemoteLLMConfig_new();

SWIGIMPORT inworld_RemoteLLMConfig* inworld_RemoteLLMConfig_copy(inworld_RemoteLLMConfig* carg1);

SWIGIMPORT void inworld_RemoteLLMConfig_delete(inworld_RemoteLLMConfig* carg1);

SWIGIMPORT bool inworld_LLMCreationConfig_has_local_llm_config(inworld_LLMCreationConfig* carg1);

SWIGIMPORT bool inworld_LLMCreationConfig_has_remote_llm_config(inworld_LLMCreationConfig* carg1);

SWIGIMPORT inworld_optional_LocalLLMConfig* inworld_LLMCreationConfig_get_local_llm_config(inworld_LLMCreationConfig* carg1);

SWIGIMPORT inworld_optional_RemoteLLMConfig* inworld_LLMCreationConfig_get_remote_llm_config(inworld_LLMCreationConfig* carg1);

SWIGIMPORT void inworld_LLMCreationConfig_set_local_llm_config(inworld_LLMCreationConfig* carg1, inworld_LocalLLMConfig* carg2);

SWIGIMPORT void inworld_LLMCreationConfig_set_remote_llm_config(inworld_LLMCreationConfig* carg1, inworld_RemoteLLMConfig* carg2);

SWIGIMPORT inworld_LLMCreationConfig* inworld_LLMCreationConfig_new();

SWIGIMPORT inworld_LLMCreationConfig* inworld_LLMCreationConfig_copy(inworld_LLMCreationConfig* carg1);

SWIGIMPORT void inworld_LLMCreationConfig_delete(inworld_LLMCreationConfig* carg1);

SWIGIMPORT void inworld_LLMFactory_delete(inworld_LLMFactory* carg1);

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_LLMFactory_CreateLLM_rcinworld_LocalLLMConfig(inworld_LLMFactory* carg1, inworld_LocalLLMConfig* carg2);

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_LLMFactory_CreateLLM_rcinworld_RemoteLLMConfig(inworld_LLMFactory* carg1, inworld_RemoteLLMConfig* carg2);

SWIGIMPORT inworld_LLMFactory* inworld_LLMFactory_new();

SWIGIMPORT inworld_LLMFactory* inworld_LLMFactory_copy(inworld_LLMFactory* carg1);

SWIGIMPORT inworld_StatusOr_LLMRouting* inworld_LLMRoutingHelper_CreateLLMRouting(inworld_CreationContext* carg1, inworld_LLMRoutingCreationConfig* carg2);

SWIGIMPORT inworld_LLMRoutingHelper* inworld_LLMRoutingHelper_new();

SWIGIMPORT inworld_LLMRoutingHelper* inworld_LLMRoutingHelper_copy(inworld_LLMRoutingHelper* carg1);

SWIGIMPORT void inworld_LLMRoutingHelper_delete(inworld_LLMRoutingHelper* carg1);

SWIGIMPORT void inworld_LLMRoutingConfig_llm_component_id_set(inworld_LLMRoutingConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LLMRoutingConfig_llm_component_id_get(inworld_LLMRoutingConfig* carg1);

SWIGIMPORT void inworld_LLMRoutingConfig_priority_set(inworld_LLMRoutingConfig* carg1, int carg2);

SWIGIMPORT int inworld_LLMRoutingConfig_priority_get(inworld_LLMRoutingConfig* carg1);

SWIGIMPORT void inworld_LLMRoutingConfig_error_cooldown_set(inworld_LLMRoutingConfig* carg1, inworld_Duration* carg2);

SWIGIMPORT inworld_Duration* inworld_LLMRoutingConfig_error_cooldown_get(inworld_LLMRoutingConfig* carg1);

SWIGIMPORT void inworld_LLMRoutingConfig_min_errors_set(inworld_LLMRoutingConfig* carg1, int carg2);

SWIGIMPORT int inworld_LLMRoutingConfig_min_errors_get(inworld_LLMRoutingConfig* carg1);

SWIGIMPORT inworld_LLMRoutingConfig* inworld_LLMRoutingConfig_new();

SWIGIMPORT inworld_LLMRoutingConfig* inworld_LLMRoutingConfig_copy(inworld_LLMRoutingConfig* carg1);

SWIGIMPORT void inworld_LLMRoutingConfig_delete(inworld_LLMRoutingConfig* carg1);

SWIGIMPORT void inworld_LLMRoutingCreationConfig_routing_configs_set(inworld_LLMRoutingCreationConfig* carg1, inworld_vector_LLMRoutingConfig* carg2);

SWIGIMPORT inworld_vector_LLMRoutingConfig* inworld_LLMRoutingCreationConfig_routing_configs_get(inworld_LLMRoutingCreationConfig* carg1);

SWIGIMPORT inworld_LLMRoutingCreationConfig* inworld_LLMRoutingCreationConfig_new();

SWIGIMPORT inworld_LLMRoutingCreationConfig* inworld_LLMRoutingCreationConfig_copy(inworld_LLMRoutingCreationConfig* carg1);

SWIGIMPORT void inworld_LLMRoutingCreationConfig_delete(inworld_LLMRoutingCreationConfig* carg1);

SWIGIMPORT inworld_ModelProperties* inworld_LLMRouting_model_properties(inworld_LLMRouting* carg1);

SWIGIMPORT bool inworld_LLMRouting_is_valid(inworld_LLMRouting* carg1);

SWIGIMPORT void inworld_KnowledgeRecord_text_set(inworld_KnowledgeRecord* carg1, const char * carg2);

SWIGIMPORT const char * inworld_KnowledgeRecord_text_get(inworld_KnowledgeRecord* carg1);

SWIGIMPORT void inworld_KnowledgeRecord_embedding_set(inworld_KnowledgeRecord* carg1, inworld_vector_float* carg2);

SWIGIMPORT inworld_vector_float* inworld_KnowledgeRecord_embedding_get(inworld_KnowledgeRecord* carg1);

SWIGIMPORT void inworld_KnowledgeRecord_metadata_set(inworld_KnowledgeRecord* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_KnowledgeRecord_metadata_get(inworld_KnowledgeRecord* carg1);

SWIGIMPORT inworld_KnowledgeRecord* inworld_KnowledgeRecord_new();

SWIGIMPORT inworld_KnowledgeRecord* inworld_KnowledgeRecord_copy(inworld_KnowledgeRecord* carg1);

SWIGIMPORT void inworld_KnowledgeRecord_delete(inworld_KnowledgeRecord* carg1);

SWIGIMPORT void inworld_KnowledgeCollection_knowledge_records_set(inworld_KnowledgeCollection* carg1, inworld_vector_KnowledgeRecord* carg2);

SWIGIMPORT inworld_vector_KnowledgeRecord* inworld_KnowledgeCollection_knowledge_records_get(inworld_KnowledgeCollection* carg1);

SWIGIMPORT inworld_KnowledgeCollection* inworld_KnowledgeCollection_new();

SWIGIMPORT inworld_KnowledgeCollection* inworld_KnowledgeCollection_copy(inworld_KnowledgeCollection* carg1);

SWIGIMPORT void inworld_KnowledgeCollection_delete(inworld_KnowledgeCollection* carg1);

SWIGIMPORT void inworld_RetrievalConfig_threshold_set(inworld_RetrievalConfig* carg1, float carg2);

SWIGIMPORT float inworld_RetrievalConfig_threshold_get(inworld_RetrievalConfig* carg1);

SWIGIMPORT void inworld_RetrievalConfig_top_k_set(inworld_RetrievalConfig* carg1, int carg2);

SWIGIMPORT int inworld_RetrievalConfig_top_k_get(inworld_RetrievalConfig* carg1);

SWIGIMPORT inworld_RetrievalConfig* inworld_RetrievalConfig_new();

SWIGIMPORT inworld_RetrievalConfig* inworld_RetrievalConfig_copy(inworld_RetrievalConfig* carg1);

SWIGIMPORT void inworld_RetrievalConfig_delete(inworld_RetrievalConfig* carg1);

SWIGIMPORT void inworld_KnowledgeRetrieverInterface_delete(inworld_KnowledgeRetrieverInterface* carg1);

SWIGIMPORT bool inworld_KnowledgeRetrieverInterface_is_valid(inworld_KnowledgeRetrieverInterface* carg1);

SWIGIMPORT inworld_StatusOr_vector_string* inworld_KnowledgeRetrieverInterface_RetrieveKnowledge(inworld_KnowledgeRetrieverInterface* carg1, inworld_RetrievalConfig* carg2, inworld_vector_KnowledgeCollection* carg3, inworld_vector_Event* carg4);

SWIGIMPORT void inworld_File_content_set(inworld_File* carg1, inworld_FileContent* carg2);

SWIGIMPORT inworld_FileContent* inworld_File_content_get(inworld_File* carg1);

SWIGIMPORT void inworld_File_type_set(inworld_File* carg1, enum inworld_File_Type carg2);

SWIGIMPORT enum inworld_File_Type inworld_File_type_get(inworld_File* carg1);

SWIGIMPORT inworld_File* inworld_File_new();

SWIGIMPORT inworld_File* inworld_File_copy(inworld_File* carg1);

SWIGIMPORT void inworld_File_delete(inworld_File* carg1);

SWIGIMPORT void inworld_FileContent_bytes_set(inworld_FileContent* carg1, inworld_vector_char* carg2);

SWIGIMPORT inworld_vector_char* inworld_FileContent_bytes_get(inworld_FileContent* carg1);

SWIGIMPORT inworld_FileContent* inworld_FileContent_new();

SWIGIMPORT inworld_FileContent* inworld_FileContent_copy(inworld_FileContent* carg1);

SWIGIMPORT void inworld_FileContent_delete(inworld_FileContent* carg1);

SWIGIMPORT void inworld_ParsingConfig_max_chars_per_chunk_set(inworld_ParsingConfig* carg1, int carg2);

SWIGIMPORT int inworld_ParsingConfig_max_chars_per_chunk_get(inworld_ParsingConfig* carg1);

SWIGIMPORT void inworld_ParsingConfig_max_chunks_per_document_set(inworld_ParsingConfig* carg1, int carg2);

SWIGIMPORT int inworld_ParsingConfig_max_chunks_per_document_get(inworld_ParsingConfig* carg1);

SWIGIMPORT inworld_ParsingConfig* inworld_ParsingConfig_new();

SWIGIMPORT inworld_ParsingConfig* inworld_ParsingConfig_copy(inworld_ParsingConfig* carg1);

SWIGIMPORT void inworld_ParsingConfig_delete(inworld_ParsingConfig* carg1);

SWIGIMPORT void inworld_KnowledgeCompileConfig_parsing_config_set(inworld_KnowledgeCompileConfig* carg1, inworld_ParsingConfig* carg2);

SWIGIMPORT inworld_ParsingConfig* inworld_KnowledgeCompileConfig_parsing_config_get(inworld_KnowledgeCompileConfig* carg1);

SWIGIMPORT inworld_KnowledgeCompileConfig* inworld_KnowledgeCompileConfig_new();

SWIGIMPORT inworld_KnowledgeCompileConfig* inworld_KnowledgeCompileConfig_copy(inworld_KnowledgeCompileConfig* carg1);

SWIGIMPORT void inworld_KnowledgeCompileConfig_delete(inworld_KnowledgeCompileConfig* carg1);

SWIGIMPORT void inworld_KnowledgeInterface_delete(inworld_KnowledgeInterface* carg1);

SWIGIMPORT inworld_Status* inworld_KnowledgeInterface_RemoveKnowledge(inworld_KnowledgeInterface* carg1, const char * carg2);

SWIGIMPORT bool inworld_KnowledgeInterface_is_valid(inworld_KnowledgeInterface* carg1);

SWIGIMPORT inworld_StatusOr_vector_string* inworld_KnowledgeInterface_GetKnowledge(inworld_KnowledgeInterface* carg1, inworld_vector_string* carg2, inworld_vector_Event* carg3);

SWIGIMPORT inworld_StatusOr_vector_string* inworld_KnowledgeInterface_CompileKnowledge_rcstd_string_rcstd_vector_Sl_std_string_Sg_(inworld_KnowledgeInterface* carg1, const char * carg2, inworld_vector_string* carg3);

SWIGIMPORT inworld_StatusOr_vector_string* inworld_KnowledgeInterface_CompileKnowledge_rcstd_string_cstd_vector_Sl_char_Sg__ceType(inworld_KnowledgeInterface* carg1, const char * carg2, inworld_vector_char* carg3, enum inworld_File_Type carg4);

SWIGIMPORT inworld_optional_LocalKnowledgeConfig* inworld_optional_LocalKnowledgeConfig_new();

SWIGIMPORT inworld_optional_LocalKnowledgeConfig* inworld_optional_LocalKnowledgeConfig_new_rcinworld_LocalKnowledgeConfig(inworld_LocalKnowledgeConfig* carg1);

SWIGIMPORT inworld_optional_LocalKnowledgeConfig* inworld_optional_LocalKnowledgeConfig_copy(inworld_optional_LocalKnowledgeConfig* carg1);

SWIGIMPORT void inworld_optional_LocalKnowledgeConfig_delete(inworld_optional_LocalKnowledgeConfig* carg1);

SWIGIMPORT bool inworld_optional_LocalKnowledgeConfig_has_value(inworld_optional_LocalKnowledgeConfig* carg1);

SWIGIMPORT inworld_LocalKnowledgeConfig* inworld_optional_LocalKnowledgeConfig_value(inworld_optional_LocalKnowledgeConfig* carg1);

SWIGIMPORT inworld_LocalKnowledgeConfig* inworld_optional_LocalKnowledgeConfig_valueConst(inworld_optional_LocalKnowledgeConfig* carg1);

SWIGIMPORT inworld_LocalKnowledgeConfig* inworld_optional_LocalKnowledgeConfig_value_or(inworld_optional_LocalKnowledgeConfig* carg1, inworld_LocalKnowledgeConfig* carg2);

SWIGIMPORT void inworld_optional_LocalKnowledgeConfig_reset(inworld_optional_LocalKnowledgeConfig* carg1);

SWIGIMPORT inworld_LocalKnowledgeConfig* inworld_optional_LocalKnowledgeConfig_get(inworld_optional_LocalKnowledgeConfig* carg1);

SWIGIMPORT inworld_LocalKnowledgeConfig* inworld_optional_LocalKnowledgeConfig_getConst(inworld_optional_LocalKnowledgeConfig* carg1);

SWIGIMPORT inworld_LocalKnowledgeConfig* inworld_optional_LocalKnowledgeConfig_get_value(inworld_optional_LocalKnowledgeConfig* carg1);

SWIGIMPORT void inworld_optional_LocalKnowledgeConfig_set_value(inworld_optional_LocalKnowledgeConfig* carg1, inworld_LocalKnowledgeConfig* carg2);

SWIGIMPORT inworld_optional_RemoteKnowledgeConfig* inworld_optional_RemoteKnowledgeConfig_new();

SWIGIMPORT inworld_optional_RemoteKnowledgeConfig* inworld_optional_RemoteKnowledgeConfig_new_rcinworld_RemoteKnowledgeConfig(inworld_RemoteKnowledgeConfig* carg1);

SWIGIMPORT inworld_optional_RemoteKnowledgeConfig* inworld_optional_RemoteKnowledgeConfig_copy(inworld_optional_RemoteKnowledgeConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteKnowledgeConfig_delete(inworld_optional_RemoteKnowledgeConfig* carg1);

SWIGIMPORT bool inworld_optional_RemoteKnowledgeConfig_has_value(inworld_optional_RemoteKnowledgeConfig* carg1);

SWIGIMPORT inworld_RemoteKnowledgeConfig* inworld_optional_RemoteKnowledgeConfig_value(inworld_optional_RemoteKnowledgeConfig* carg1);

SWIGIMPORT inworld_RemoteKnowledgeConfig* inworld_optional_RemoteKnowledgeConfig_valueConst(inworld_optional_RemoteKnowledgeConfig* carg1);

SWIGIMPORT inworld_RemoteKnowledgeConfig* inworld_optional_RemoteKnowledgeConfig_value_or(inworld_optional_RemoteKnowledgeConfig* carg1, inworld_RemoteKnowledgeConfig* carg2);

SWIGIMPORT void inworld_optional_RemoteKnowledgeConfig_reset(inworld_optional_RemoteKnowledgeConfig* carg1);

SWIGIMPORT inworld_RemoteKnowledgeConfig* inworld_optional_RemoteKnowledgeConfig_get(inworld_optional_RemoteKnowledgeConfig* carg1);

SWIGIMPORT inworld_RemoteKnowledgeConfig* inworld_optional_RemoteKnowledgeConfig_getConst(inworld_optional_RemoteKnowledgeConfig* carg1);

SWIGIMPORT inworld_RemoteKnowledgeConfig* inworld_optional_RemoteKnowledgeConfig_get_value(inworld_optional_RemoteKnowledgeConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteKnowledgeConfig_set_value(inworld_optional_RemoteKnowledgeConfig* carg1, inworld_RemoteKnowledgeConfig* carg2);

SWIGIMPORT void inworld_LocalKnowledgeConfig_knowledge_compile_config_set(inworld_LocalKnowledgeConfig* carg1, inworld_KnowledgeCompileConfig* carg2);

SWIGIMPORT inworld_KnowledgeCompileConfig* inworld_LocalKnowledgeConfig_knowledge_compile_config_get(inworld_LocalKnowledgeConfig* carg1);

SWIGIMPORT void inworld_LocalKnowledgeConfig_embedder_component_id_set(inworld_LocalKnowledgeConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LocalKnowledgeConfig_embedder_component_id_get(inworld_LocalKnowledgeConfig* carg1);

SWIGIMPORT inworld_LocalKnowledgeConfig* inworld_LocalKnowledgeConfig_new();

SWIGIMPORT inworld_LocalKnowledgeConfig* inworld_LocalKnowledgeConfig_copy(inworld_LocalKnowledgeConfig* carg1);

SWIGIMPORT void inworld_LocalKnowledgeConfig_delete(inworld_LocalKnowledgeConfig* carg1);

SWIGIMPORT void inworld_RemoteKnowledgeConfig_knowledge_compile_config_set(inworld_RemoteKnowledgeConfig* carg1, inworld_KnowledgeCompileConfig* carg2);

SWIGIMPORT inworld_KnowledgeCompileConfig* inworld_RemoteKnowledgeConfig_knowledge_compile_config_get(inworld_RemoteKnowledgeConfig* carg1);

SWIGIMPORT void inworld_RemoteKnowledgeConfig_api_key_set(inworld_RemoteKnowledgeConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RemoteKnowledgeConfig_api_key_get(inworld_RemoteKnowledgeConfig* carg1);

SWIGIMPORT void inworld_RemoteKnowledgeConfig_language_set(inworld_RemoteKnowledgeConfig* carg1, inworld_Language* carg2);

SWIGIMPORT inworld_Language* inworld_RemoteKnowledgeConfig_language_get(inworld_RemoteKnowledgeConfig* carg1);

SWIGIMPORT inworld_RemoteKnowledgeConfig* inworld_RemoteKnowledgeConfig_new();

SWIGIMPORT inworld_RemoteKnowledgeConfig* inworld_RemoteKnowledgeConfig_copy(inworld_RemoteKnowledgeConfig* carg1);

SWIGIMPORT void inworld_RemoteKnowledgeConfig_delete(inworld_RemoteKnowledgeConfig* carg1);

SWIGIMPORT bool inworld_KnowledgeCreationConfig_has_local_config(inworld_KnowledgeCreationConfig* carg1);

SWIGIMPORT bool inworld_KnowledgeCreationConfig_has_remote_config(inworld_KnowledgeCreationConfig* carg1);

SWIGIMPORT inworld_optional_LocalKnowledgeConfig* inworld_KnowledgeCreationConfig_get_local_config(inworld_KnowledgeCreationConfig* carg1);

SWIGIMPORT inworld_optional_RemoteKnowledgeConfig* inworld_KnowledgeCreationConfig_get_remote_config(inworld_KnowledgeCreationConfig* carg1);

SWIGIMPORT void inworld_KnowledgeCreationConfig_set_local_config(inworld_KnowledgeCreationConfig* carg1, inworld_LocalKnowledgeConfig* carg2);

SWIGIMPORT void inworld_KnowledgeCreationConfig_set_remote_config(inworld_KnowledgeCreationConfig* carg1, inworld_RemoteKnowledgeConfig* carg2);

SWIGIMPORT bool inworld_KnowledgeCreationConfig_is_valid(inworld_KnowledgeCreationConfig* carg1);

SWIGIMPORT inworld_KnowledgeCreationConfig* inworld_KnowledgeCreationConfig_new();

SWIGIMPORT inworld_KnowledgeCreationConfig* inworld_KnowledgeCreationConfig_copy(inworld_KnowledgeCreationConfig* carg1);

SWIGIMPORT void inworld_KnowledgeCreationConfig_delete(inworld_KnowledgeCreationConfig* carg1);

SWIGIMPORT void inworld_KnowledgeFactory_delete(inworld_KnowledgeFactory* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeInterface* inworld_KnowledgeFactory_CreateKnowledge_rcinworld_CreationContext_rcinworld_LocalKnowledgeConfig(inworld_KnowledgeFactory* carg1, inworld_CreationContext* carg2, inworld_LocalKnowledgeConfig* carg3);

SWIGIMPORT inworld_StatusOr_KnowledgeInterface* inworld_KnowledgeFactory_CreateKnowledge_rcinworld_CreationContext_rcinworld_RemoteKnowledgeConfig(inworld_KnowledgeFactory* carg1, inworld_CreationContext* carg2, inworld_RemoteKnowledgeConfig* carg3);

SWIGIMPORT inworld_KnowledgeFactory* inworld_KnowledgeFactory_new();

SWIGIMPORT inworld_KnowledgeFactory* inworld_KnowledgeFactory_copy(inworld_KnowledgeFactory* carg1);

SWIGIMPORT void inworld_KnowledgeCollectionFactory_delete(inworld_KnowledgeCollectionFactory* carg1);

SWIGIMPORT inworld_KnowledgeCollection* inworld_KnowledgeCollectionFactory_CreateKnowledgeCollection(inworld_KnowledgeCollectionFactory* carg1, inworld_TextEmbedderInterface* carg2, inworld_vector_string* carg3);

SWIGIMPORT inworld_KnowledgeCollectionFactory* inworld_KnowledgeCollectionFactory_new();

SWIGIMPORT inworld_KnowledgeCollectionFactory* inworld_KnowledgeCollectionFactory_copy(inworld_KnowledgeCollectionFactory* carg1);

SWIGIMPORT void inworld_KnowledgeRetrieverFactory_delete(inworld_KnowledgeRetrieverFactory* carg1);

SWIGIMPORT inworld_StatusOr_KnowledgeRetrieverInterface* inworld_KnowledgeRetrieverFactory_CreateKnowledgeRetriever(inworld_KnowledgeRetrieverFactory* carg1, inworld_TextEmbedderInterface* carg2);

SWIGIMPORT inworld_KnowledgeRetrieverFactory* inworld_KnowledgeRetrieverFactory_new();

SWIGIMPORT inworld_KnowledgeRetrieverFactory* inworld_KnowledgeRetrieverFactory_copy(inworld_KnowledgeRetrieverFactory* carg1);

SWIGIMPORT inworld_optional_RollingSummaryConfig* inworld_optional_RollingSummaryConfig_new();

SWIGIMPORT inworld_optional_RollingSummaryConfig* inworld_optional_RollingSummaryConfig_new_rcinworld_RollingSummaryConfig(inworld_RollingSummaryConfig* carg1);

SWIGIMPORT inworld_optional_RollingSummaryConfig* inworld_optional_RollingSummaryConfig_copy(inworld_optional_RollingSummaryConfig* carg1);

SWIGIMPORT void inworld_optional_RollingSummaryConfig_delete(inworld_optional_RollingSummaryConfig* carg1);

SWIGIMPORT bool inworld_optional_RollingSummaryConfig_has_value(inworld_optional_RollingSummaryConfig* carg1);

SWIGIMPORT inworld_RollingSummaryConfig* inworld_optional_RollingSummaryConfig_value(inworld_optional_RollingSummaryConfig* carg1);

SWIGIMPORT inworld_RollingSummaryConfig* inworld_optional_RollingSummaryConfig_valueConst(inworld_optional_RollingSummaryConfig* carg1);

SWIGIMPORT inworld_RollingSummaryConfig* inworld_optional_RollingSummaryConfig_value_or(inworld_optional_RollingSummaryConfig* carg1, inworld_RollingSummaryConfig* carg2);

SWIGIMPORT void inworld_optional_RollingSummaryConfig_reset(inworld_optional_RollingSummaryConfig* carg1);

SWIGIMPORT inworld_RollingSummaryConfig* inworld_optional_RollingSummaryConfig_get(inworld_optional_RollingSummaryConfig* carg1);

SWIGIMPORT inworld_RollingSummaryConfig* inworld_optional_RollingSummaryConfig_getConst(inworld_optional_RollingSummaryConfig* carg1);

SWIGIMPORT inworld_RollingSummaryConfig* inworld_optional_RollingSummaryConfig_get_value(inworld_optional_RollingSummaryConfig* carg1);

SWIGIMPORT void inworld_optional_RollingSummaryConfig_set_value(inworld_optional_RollingSummaryConfig* carg1, inworld_RollingSummaryConfig* carg2);

SWIGIMPORT inworld_optional_FlashMemoryConfig* inworld_optional_FlashMemoryConfig_new();

SWIGIMPORT inworld_optional_FlashMemoryConfig* inworld_optional_FlashMemoryConfig_new_rcinworld_FlashMemoryConfig(inworld_FlashMemoryConfig* carg1);

SWIGIMPORT inworld_optional_FlashMemoryConfig* inworld_optional_FlashMemoryConfig_copy(inworld_optional_FlashMemoryConfig* carg1);

SWIGIMPORT void inworld_optional_FlashMemoryConfig_delete(inworld_optional_FlashMemoryConfig* carg1);

SWIGIMPORT bool inworld_optional_FlashMemoryConfig_has_value(inworld_optional_FlashMemoryConfig* carg1);

SWIGIMPORT inworld_FlashMemoryConfig* inworld_optional_FlashMemoryConfig_value(inworld_optional_FlashMemoryConfig* carg1);

SWIGIMPORT inworld_FlashMemoryConfig* inworld_optional_FlashMemoryConfig_valueConst(inworld_optional_FlashMemoryConfig* carg1);

SWIGIMPORT inworld_FlashMemoryConfig* inworld_optional_FlashMemoryConfig_value_or(inworld_optional_FlashMemoryConfig* carg1, inworld_FlashMemoryConfig* carg2);

SWIGIMPORT void inworld_optional_FlashMemoryConfig_reset(inworld_optional_FlashMemoryConfig* carg1);

SWIGIMPORT inworld_FlashMemoryConfig* inworld_optional_FlashMemoryConfig_get(inworld_optional_FlashMemoryConfig* carg1);

SWIGIMPORT inworld_FlashMemoryConfig* inworld_optional_FlashMemoryConfig_getConst(inworld_optional_FlashMemoryConfig* carg1);

SWIGIMPORT inworld_FlashMemoryConfig* inworld_optional_FlashMemoryConfig_get_value(inworld_optional_FlashMemoryConfig* carg1);

SWIGIMPORT void inworld_optional_FlashMemoryConfig_set_value(inworld_optional_FlashMemoryConfig* carg1, inworld_FlashMemoryConfig* carg2);

SWIGIMPORT inworld_optional_LongTermMemoryConfig* inworld_optional_LongTermMemoryConfig_new();

SWIGIMPORT inworld_optional_LongTermMemoryConfig* inworld_optional_LongTermMemoryConfig_new_rcinworld_LongTermMemoryConfig(inworld_LongTermMemoryConfig* carg1);

SWIGIMPORT inworld_optional_LongTermMemoryConfig* inworld_optional_LongTermMemoryConfig_copy(inworld_optional_LongTermMemoryConfig* carg1);

SWIGIMPORT void inworld_optional_LongTermMemoryConfig_delete(inworld_optional_LongTermMemoryConfig* carg1);

SWIGIMPORT bool inworld_optional_LongTermMemoryConfig_has_value(inworld_optional_LongTermMemoryConfig* carg1);

SWIGIMPORT inworld_LongTermMemoryConfig* inworld_optional_LongTermMemoryConfig_value(inworld_optional_LongTermMemoryConfig* carg1);

SWIGIMPORT inworld_LongTermMemoryConfig* inworld_optional_LongTermMemoryConfig_valueConst(inworld_optional_LongTermMemoryConfig* carg1);

SWIGIMPORT inworld_LongTermMemoryConfig* inworld_optional_LongTermMemoryConfig_value_or(inworld_optional_LongTermMemoryConfig* carg1, inworld_LongTermMemoryConfig* carg2);

SWIGIMPORT void inworld_optional_LongTermMemoryConfig_reset(inworld_optional_LongTermMemoryConfig* carg1);

SWIGIMPORT inworld_LongTermMemoryConfig* inworld_optional_LongTermMemoryConfig_get(inworld_optional_LongTermMemoryConfig* carg1);

SWIGIMPORT inworld_LongTermMemoryConfig* inworld_optional_LongTermMemoryConfig_getConst(inworld_optional_LongTermMemoryConfig* carg1);

SWIGIMPORT inworld_LongTermMemoryConfig* inworld_optional_LongTermMemoryConfig_get_value(inworld_optional_LongTermMemoryConfig* carg1);

SWIGIMPORT void inworld_optional_LongTermMemoryConfig_set_value(inworld_optional_LongTermMemoryConfig* carg1, inworld_LongTermMemoryConfig* carg2);

SWIGIMPORT void inworld_RollingSummary_summarized_text_set(inworld_RollingSummary* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RollingSummary_summarized_text_get(inworld_RollingSummary* carg1);

SWIGIMPORT void inworld_RollingSummary_turns_since_last_update_set(inworld_RollingSummary* carg1, int carg2);

SWIGIMPORT int inworld_RollingSummary_turns_since_last_update_get(inworld_RollingSummary* carg1);

SWIGIMPORT inworld_RollingSummary* inworld_RollingSummary_new();

SWIGIMPORT inworld_RollingSummary* inworld_RollingSummary_copy(inworld_RollingSummary* carg1);

SWIGIMPORT void inworld_RollingSummary_delete(inworld_RollingSummary* carg1);

SWIGIMPORT void inworld_FlashMemory_knowledge_collection_set(inworld_FlashMemory* carg1, inworld_KnowledgeCollection* carg2);

SWIGIMPORT inworld_KnowledgeCollection* inworld_FlashMemory_knowledge_collection_get(inworld_FlashMemory* carg1);

SWIGIMPORT inworld_FlashMemory* inworld_FlashMemory_new();

SWIGIMPORT inworld_FlashMemory* inworld_FlashMemory_copy(inworld_FlashMemory* carg1);

SWIGIMPORT void inworld_FlashMemory_delete(inworld_FlashMemory* carg1);

SWIGIMPORT void inworld_LongTermMemory_knowledge_collection_set(inworld_LongTermMemory* carg1, inworld_KnowledgeCollection* carg2);

SWIGIMPORT inworld_KnowledgeCollection* inworld_LongTermMemory_knowledge_collection_get(inworld_LongTermMemory* carg1);

SWIGIMPORT inworld_LongTermMemory* inworld_LongTermMemory_new();

SWIGIMPORT inworld_LongTermMemory* inworld_LongTermMemory_copy(inworld_LongTermMemory* carg1);

SWIGIMPORT void inworld_LongTermMemory_delete(inworld_LongTermMemory* carg1);

SWIGIMPORT void inworld_MemorySnapshot_rolling_summary_set(inworld_MemorySnapshot* carg1, inworld_RollingSummary* carg2);

SWIGIMPORT inworld_RollingSummary* inworld_MemorySnapshot_rolling_summary_get(inworld_MemorySnapshot* carg1);

SWIGIMPORT void inworld_MemorySnapshot_flash_memory_set(inworld_MemorySnapshot* carg1, inworld_FlashMemory* carg2);

SWIGIMPORT inworld_FlashMemory* inworld_MemorySnapshot_flash_memory_get(inworld_MemorySnapshot* carg1);

SWIGIMPORT void inworld_MemorySnapshot_long_term_memory_set(inworld_MemorySnapshot* carg1, inworld_LongTermMemory* carg2);

SWIGIMPORT inworld_LongTermMemory* inworld_MemorySnapshot_long_term_memory_get(inworld_MemorySnapshot* carg1);

SWIGIMPORT inworld_MemorySnapshot* inworld_MemorySnapshot_new();

SWIGIMPORT inworld_MemorySnapshot* inworld_MemorySnapshot_copy(inworld_MemorySnapshot* carg1);

SWIGIMPORT void inworld_MemorySnapshot_delete(inworld_MemorySnapshot* carg1);

SWIGIMPORT void inworld_RollingSummaryConfig_number_of_turns_before_summary_set(inworld_RollingSummaryConfig* carg1, int carg2);

SWIGIMPORT int inworld_RollingSummaryConfig_number_of_turns_before_summary_get(inworld_RollingSummaryConfig* carg1);

SWIGIMPORT void inworld_RollingSummaryConfig_start_window_size_set(inworld_RollingSummaryConfig* carg1, int carg2);

SWIGIMPORT int inworld_RollingSummaryConfig_start_window_size_get(inworld_RollingSummaryConfig* carg1);

SWIGIMPORT void inworld_RollingSummaryConfig_text_generation_config_set(inworld_RollingSummaryConfig* carg1, inworld_TextGenerationConfig* carg2);

SWIGIMPORT inworld_TextGenerationConfig* inworld_RollingSummaryConfig_text_generation_config_get(inworld_RollingSummaryConfig* carg1);

SWIGIMPORT void inworld_RollingSummaryConfig_max_summary_sentences_set(inworld_RollingSummaryConfig* carg1, int carg2);

SWIGIMPORT int inworld_RollingSummaryConfig_max_summary_sentences_get(inworld_RollingSummaryConfig* carg1);

SWIGIMPORT inworld_RollingSummaryConfig* inworld_RollingSummaryConfig_new();

SWIGIMPORT inworld_RollingSummaryConfig* inworld_RollingSummaryConfig_copy(inworld_RollingSummaryConfig* carg1);

SWIGIMPORT void inworld_RollingSummaryConfig_delete(inworld_RollingSummaryConfig* carg1);

SWIGIMPORT void inworld_FlashMemoryConfig_dialogue_cutoff_size_set(inworld_FlashMemoryConfig* carg1, int carg2);

SWIGIMPORT int inworld_FlashMemoryConfig_dialogue_cutoff_size_get(inworld_FlashMemoryConfig* carg1);

SWIGIMPORT void inworld_FlashMemoryConfig_n_history_turns_set(inworld_FlashMemoryConfig* carg1, int carg2);

SWIGIMPORT int inworld_FlashMemoryConfig_n_history_turns_get(inworld_FlashMemoryConfig* carg1);

SWIGIMPORT void inworld_FlashMemoryConfig_memories_similarity_threshold_set(inworld_FlashMemoryConfig* carg1, float carg2);

SWIGIMPORT float inworld_FlashMemoryConfig_memories_similarity_threshold_get(inworld_FlashMemoryConfig* carg1);

SWIGIMPORT void inworld_FlashMemoryConfig_max_flash_memory_set(inworld_FlashMemoryConfig* carg1, int carg2);

SWIGIMPORT int inworld_FlashMemoryConfig_max_flash_memory_get(inworld_FlashMemoryConfig* carg1);

SWIGIMPORT void inworld_FlashMemoryConfig_max_topics_per_memory_set(inworld_FlashMemoryConfig* carg1, int carg2);

SWIGIMPORT int inworld_FlashMemoryConfig_max_topics_per_memory_get(inworld_FlashMemoryConfig* carg1);

SWIGIMPORT void inworld_FlashMemoryConfig_text_generation_config_set(inworld_FlashMemoryConfig* carg1, inworld_TextGenerationConfig* carg2);

SWIGIMPORT inworld_TextGenerationConfig* inworld_FlashMemoryConfig_text_generation_config_get(inworld_FlashMemoryConfig* carg1);

SWIGIMPORT inworld_FlashMemoryConfig* inworld_FlashMemoryConfig_new();

SWIGIMPORT inworld_FlashMemoryConfig* inworld_FlashMemoryConfig_copy(inworld_FlashMemoryConfig* carg1);

SWIGIMPORT void inworld_FlashMemoryConfig_delete(inworld_FlashMemoryConfig* carg1);

SWIGIMPORT void inworld_LongTermMemoryConfig_max_topic_summary_len_to_append_set(inworld_LongTermMemoryConfig* carg1, int carg2);

SWIGIMPORT int inworld_LongTermMemoryConfig_max_topic_summary_len_to_append_get(inworld_LongTermMemoryConfig* carg1);

SWIGIMPORT void inworld_LongTermMemoryConfig_max_number_of_flash_memory_set(inworld_LongTermMemoryConfig* carg1, int carg2);

SWIGIMPORT int inworld_LongTermMemoryConfig_max_number_of_flash_memory_get(inworld_LongTermMemoryConfig* carg1);

SWIGIMPORT void inworld_LongTermMemoryConfig_max_number_of_topics_set(inworld_LongTermMemoryConfig* carg1, int carg2);

SWIGIMPORT int inworld_LongTermMemoryConfig_max_number_of_topics_get(inworld_LongTermMemoryConfig* carg1);

SWIGIMPORT void inworld_LongTermMemoryConfig_text_generation_config_set(inworld_LongTermMemoryConfig* carg1, inworld_TextGenerationConfig* carg2);

SWIGIMPORT inworld_TextGenerationConfig* inworld_LongTermMemoryConfig_text_generation_config_get(inworld_LongTermMemoryConfig* carg1);

SWIGIMPORT inworld_LongTermMemoryConfig* inworld_LongTermMemoryConfig_new();

SWIGIMPORT inworld_LongTermMemoryConfig* inworld_LongTermMemoryConfig_copy(inworld_LongTermMemoryConfig* carg1);

SWIGIMPORT void inworld_LongTermMemoryConfig_delete(inworld_LongTermMemoryConfig* carg1);

SWIGIMPORT void inworld_MemoryUpdateConfig_rolling_summary_config_set(inworld_MemoryUpdateConfig* carg1, inworld_optional_RollingSummaryConfig* carg2);

SWIGIMPORT inworld_optional_RollingSummaryConfig* inworld_MemoryUpdateConfig_rolling_summary_config_get(inworld_MemoryUpdateConfig* carg1);

SWIGIMPORT void inworld_MemoryUpdateConfig_flash_memory_config_set(inworld_MemoryUpdateConfig* carg1, inworld_optional_FlashMemoryConfig* carg2);

SWIGIMPORT inworld_optional_FlashMemoryConfig* inworld_MemoryUpdateConfig_flash_memory_config_get(inworld_MemoryUpdateConfig* carg1);

SWIGIMPORT void inworld_MemoryUpdateConfig_long_term_memory_config_set(inworld_MemoryUpdateConfig* carg1, inworld_optional_LongTermMemoryConfig* carg2);

SWIGIMPORT inworld_optional_LongTermMemoryConfig* inworld_MemoryUpdateConfig_long_term_memory_config_get(inworld_MemoryUpdateConfig* carg1);

SWIGIMPORT inworld_MemoryUpdateConfig* inworld_MemoryUpdateConfig_new();

SWIGIMPORT inworld_MemoryUpdateConfig* inworld_MemoryUpdateConfig_copy(inworld_MemoryUpdateConfig* carg1);

SWIGIMPORT void inworld_MemoryUpdateConfig_delete(inworld_MemoryUpdateConfig* carg1);

SWIGIMPORT void inworld_MemoryInterface_delete(inworld_MemoryInterface* carg1);

SWIGIMPORT bool inworld_MemoryInterface_is_valid(inworld_MemoryInterface* carg1);

SWIGIMPORT inworld_StatusOr_vector_string* inworld_MemoryInterface_GetMemory_rcstd_vector_Sl_inworld_Event_Sg__rcinworld_MemorySnapshot_rcinworld_RetrievalConfig_b(inworld_MemoryInterface* carg1, inworld_vector_Event* carg2, inworld_MemorySnapshot* carg3, inworld_RetrievalConfig* carg4, bool carg5);

SWIGIMPORT inworld_StatusOr_vector_string* inworld_MemoryInterface_GetMemory_rcstd_vector_Sl_inworld_Event_Sg__rcinworld_MemorySnapshot_rcinworld_RetrievalConfig(inworld_MemoryInterface* carg1, inworld_vector_Event* carg2, inworld_MemorySnapshot* carg3, inworld_RetrievalConfig* carg4);

SWIGIMPORT inworld_StatusOr_MemorySnapshot* inworld_MemoryInterface_UpdateMemory(inworld_MemoryInterface* carg1, inworld_vector_Event* carg2, inworld_MemorySnapshot* carg3);

SWIGIMPORT void inworld_MemoryFactory_delete(inworld_MemoryFactory* carg1);

SWIGIMPORT inworld_StatusOr_MemoryInterface* inworld_MemoryFactory_CreateMemory(inworld_MemoryFactory* carg1, inworld_LLMInterface* carg2, inworld_TextEmbedderInterface* carg3, inworld_RollingSummaryConfig* carg4, inworld_FlashMemoryConfig* carg5, inworld_LongTermMemoryConfig* carg6, inworld_RetrievalConfig* carg7, bool carg8);

SWIGIMPORT inworld_MemoryFactory* inworld_MemoryFactory_new();

SWIGIMPORT inworld_MemoryFactory* inworld_MemoryFactory_copy(inworld_MemoryFactory* carg1);

SWIGIMPORT void inworld_IntentCompilerInterface_delete(inworld_IntentCompilerInterface* carg1);

SWIGIMPORT inworld_StatusOr_vector_CompiledIntent* inworld_IntentCompilerInterface_CompileIntents(inworld_IntentCompilerInterface* carg1, inworld_vector_Intent* carg2);

SWIGIMPORT bool inworld_IntentCompilerInterface_is_valid(inworld_IntentCompilerInterface* carg1);

SWIGIMPORT void inworld_IntentCompilerFactory_delete(inworld_IntentCompilerFactory* carg1);

SWIGIMPORT inworld_StatusOr_IntentCompilerInterface* inworld_IntentCompilerFactory_CreateIntentCompiler_std_shared_ptr_Sl_inworld_TextEmbedderInterface_SS_const_Sg_(inworld_IntentCompilerFactory* carg1, inworld_TextEmbedderInterface* carg2);

SWIGIMPORT inworld_StatusOr_IntentCompilerInterface* inworld_IntentCompilerFactory_CreateIntentCompiler(inworld_IntentCompilerFactory* carg1);

SWIGIMPORT inworld_IntentCompilerFactory* inworld_IntentCompilerFactory_new();

SWIGIMPORT inworld_IntentCompilerFactory* inworld_IntentCompilerFactory_copy(inworld_IntentCompilerFactory* carg1);

SWIGIMPORT inworld_optional_LlmMatcherConfig* inworld_optional_LlmMatcherConfig_new();

SWIGIMPORT inworld_optional_LlmMatcherConfig* inworld_optional_LlmMatcherConfig_new_rcinworld_LlmMatcherConfig(inworld_LlmMatcherConfig* carg1);

SWIGIMPORT inworld_optional_LlmMatcherConfig* inworld_optional_LlmMatcherConfig_copy(inworld_optional_LlmMatcherConfig* carg1);

SWIGIMPORT void inworld_optional_LlmMatcherConfig_delete(inworld_optional_LlmMatcherConfig* carg1);

SWIGIMPORT bool inworld_optional_LlmMatcherConfig_has_value(inworld_optional_LlmMatcherConfig* carg1);

SWIGIMPORT inworld_LlmMatcherConfig* inworld_optional_LlmMatcherConfig_value(inworld_optional_LlmMatcherConfig* carg1);

SWIGIMPORT inworld_LlmMatcherConfig* inworld_optional_LlmMatcherConfig_valueConst(inworld_optional_LlmMatcherConfig* carg1);

SWIGIMPORT inworld_LlmMatcherConfig* inworld_optional_LlmMatcherConfig_value_or(inworld_optional_LlmMatcherConfig* carg1, inworld_LlmMatcherConfig* carg2);

SWIGIMPORT void inworld_optional_LlmMatcherConfig_reset(inworld_optional_LlmMatcherConfig* carg1);

SWIGIMPORT inworld_LlmMatcherConfig* inworld_optional_LlmMatcherConfig_get(inworld_optional_LlmMatcherConfig* carg1);

SWIGIMPORT inworld_LlmMatcherConfig* inworld_optional_LlmMatcherConfig_getConst(inworld_optional_LlmMatcherConfig* carg1);

SWIGIMPORT inworld_LlmMatcherConfig* inworld_optional_LlmMatcherConfig_get_value(inworld_optional_LlmMatcherConfig* carg1);

SWIGIMPORT void inworld_optional_LlmMatcherConfig_set_value(inworld_optional_LlmMatcherConfig* carg1, inworld_LlmMatcherConfig* carg2);

SWIGIMPORT inworld_optional_TextEmbedderInterface* inworld_optional_TextEmbedderInterface_new();

SWIGIMPORT inworld_optional_TextEmbedderInterface* inworld_optional_TextEmbedderInterface_new_rcstd_shared_ptr_Sl_inworld_TextEmbedderInterface_SS_const_Sg_(inworld_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_optional_TextEmbedderInterface* inworld_optional_TextEmbedderInterface_copy(inworld_optional_TextEmbedderInterface* carg1);

SWIGIMPORT void inworld_optional_TextEmbedderInterface_delete(inworld_optional_TextEmbedderInterface* carg1);

SWIGIMPORT bool inworld_optional_TextEmbedderInterface_has_value(inworld_optional_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_TextEmbedderInterface* inworld_optional_TextEmbedderInterface_value(inworld_optional_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_TextEmbedderInterface* inworld_optional_TextEmbedderInterface_valueConst(inworld_optional_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_TextEmbedderInterface* inworld_optional_TextEmbedderInterface_value_or(inworld_optional_TextEmbedderInterface* carg1, inworld_TextEmbedderInterface* carg2);

SWIGIMPORT void inworld_optional_TextEmbedderInterface_reset(inworld_optional_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_TextEmbedderInterface* inworld_optional_TextEmbedderInterface_get(inworld_optional_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_TextEmbedderInterface* inworld_optional_TextEmbedderInterface_getConst(inworld_optional_TextEmbedderInterface* carg1);

SWIGIMPORT inworld_TextEmbedderInterface* inworld_optional_TextEmbedderInterface_get_value(inworld_optional_TextEmbedderInterface* carg1);

SWIGIMPORT void inworld_optional_TextEmbedderInterface_set_value(inworld_optional_TextEmbedderInterface* carg1, inworld_TextEmbedderInterface* carg2);

SWIGIMPORT inworld_optional_EmbeddingMatcherConfig* inworld_optional_EmbeddingMatcherConfig_new();

SWIGIMPORT inworld_optional_EmbeddingMatcherConfig* inworld_optional_EmbeddingMatcherConfig_new_rcinworld_EmbeddingMatcherConfig(inworld_EmbeddingMatcherConfig* carg1);

SWIGIMPORT inworld_optional_EmbeddingMatcherConfig* inworld_optional_EmbeddingMatcherConfig_copy(inworld_optional_EmbeddingMatcherConfig* carg1);

SWIGIMPORT void inworld_optional_EmbeddingMatcherConfig_delete(inworld_optional_EmbeddingMatcherConfig* carg1);

SWIGIMPORT bool inworld_optional_EmbeddingMatcherConfig_has_value(inworld_optional_EmbeddingMatcherConfig* carg1);

SWIGIMPORT inworld_EmbeddingMatcherConfig* inworld_optional_EmbeddingMatcherConfig_value(inworld_optional_EmbeddingMatcherConfig* carg1);

SWIGIMPORT inworld_EmbeddingMatcherConfig* inworld_optional_EmbeddingMatcherConfig_valueConst(inworld_optional_EmbeddingMatcherConfig* carg1);

SWIGIMPORT inworld_EmbeddingMatcherConfig* inworld_optional_EmbeddingMatcherConfig_value_or(inworld_optional_EmbeddingMatcherConfig* carg1, inworld_EmbeddingMatcherConfig* carg2);

SWIGIMPORT void inworld_optional_EmbeddingMatcherConfig_reset(inworld_optional_EmbeddingMatcherConfig* carg1);

SWIGIMPORT inworld_EmbeddingMatcherConfig* inworld_optional_EmbeddingMatcherConfig_get(inworld_optional_EmbeddingMatcherConfig* carg1);

SWIGIMPORT inworld_EmbeddingMatcherConfig* inworld_optional_EmbeddingMatcherConfig_getConst(inworld_optional_EmbeddingMatcherConfig* carg1);

SWIGIMPORT inworld_EmbeddingMatcherConfig* inworld_optional_EmbeddingMatcherConfig_get_value(inworld_optional_EmbeddingMatcherConfig* carg1);

SWIGIMPORT void inworld_optional_EmbeddingMatcherConfig_set_value(inworld_optional_EmbeddingMatcherConfig* carg1, inworld_EmbeddingMatcherConfig* carg2);

SWIGIMPORT void inworld_IntentMatch_intent_name_set(inworld_IntentMatch* carg1, const char * carg2);

SWIGIMPORT const char * inworld_IntentMatch_intent_name_get(inworld_IntentMatch* carg1);

SWIGIMPORT void inworld_IntentMatch_score_set(inworld_IntentMatch* carg1, float carg2);

SWIGIMPORT float inworld_IntentMatch_score_get(inworld_IntentMatch* carg1);

SWIGIMPORT inworld_IntentMatch* inworld_IntentMatch_new();

SWIGIMPORT inworld_IntentMatch* inworld_IntentMatch_copy(inworld_IntentMatch* carg1);

SWIGIMPORT void inworld_IntentMatch_delete(inworld_IntentMatch* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherConfig_similarity_threshold_set(inworld_EmbeddingMatcherConfig* carg1, float carg2);

SWIGIMPORT float inworld_EmbeddingMatcherConfig_similarity_threshold_get(inworld_EmbeddingMatcherConfig* carg1);

SWIGIMPORT inworld_EmbeddingMatcherConfig* inworld_EmbeddingMatcherConfig_new();

SWIGIMPORT inworld_EmbeddingMatcherConfig* inworld_EmbeddingMatcherConfig_copy(inworld_EmbeddingMatcherConfig* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherConfig_delete(inworld_EmbeddingMatcherConfig* carg1);

SWIGIMPORT void inworld_LlmMatcherConfig_generation_config_set(inworld_LlmMatcherConfig* carg1, inworld_TextGenerationConfig* carg2);

SWIGIMPORT inworld_TextGenerationConfig* inworld_LlmMatcherConfig_generation_config_get(inworld_LlmMatcherConfig* carg1);

SWIGIMPORT void inworld_LlmMatcherConfig_prompt_template_set(inworld_LlmMatcherConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LlmMatcherConfig_prompt_template_get(inworld_LlmMatcherConfig* carg1);

SWIGIMPORT void inworld_LlmMatcherConfig_embedding_similarity_threshold_set(inworld_LlmMatcherConfig* carg1, inworld_optional_float* carg2);

SWIGIMPORT inworld_optional_float* inworld_LlmMatcherConfig_embedding_similarity_threshold_get(inworld_LlmMatcherConfig* carg1);

SWIGIMPORT void inworld_LlmMatcherConfig_max_embedding_matches_for_llm_set(inworld_LlmMatcherConfig* carg1, inworld_optional_int* carg2);

SWIGIMPORT inworld_optional_int* inworld_LlmMatcherConfig_max_embedding_matches_for_llm_get(inworld_LlmMatcherConfig* carg1);

SWIGIMPORT inworld_LlmMatcherConfig* inworld_LlmMatcherConfig_new();

SWIGIMPORT inworld_LlmMatcherConfig* inworld_LlmMatcherConfig_copy(inworld_LlmMatcherConfig* carg1);

SWIGIMPORT void inworld_LlmMatcherConfig_delete(inworld_LlmMatcherConfig* carg1);

SWIGIMPORT void inworld_IntentMatcherConfig_embedding_set(inworld_IntentMatcherConfig* carg1, inworld_optional_EmbeddingMatcherConfig* carg2);

SWIGIMPORT inworld_optional_EmbeddingMatcherConfig* inworld_IntentMatcherConfig_embedding_get(inworld_IntentMatcherConfig* carg1);

SWIGIMPORT void inworld_IntentMatcherConfig_llm_set(inworld_IntentMatcherConfig* carg1, inworld_optional_LlmMatcherConfig* carg2);

SWIGIMPORT inworld_optional_LlmMatcherConfig* inworld_IntentMatcherConfig_llm_get(inworld_IntentMatcherConfig* carg1);

SWIGIMPORT void inworld_IntentMatcherConfig_top_n_intents_set(inworld_IntentMatcherConfig* carg1, int carg2);

SWIGIMPORT int inworld_IntentMatcherConfig_top_n_intents_get(inworld_IntentMatcherConfig* carg1);

SWIGIMPORT inworld_IntentMatcherConfig* inworld_IntentMatcherConfig_new();

SWIGIMPORT inworld_IntentMatcherConfig* inworld_IntentMatcherConfig_copy(inworld_IntentMatcherConfig* carg1);

SWIGIMPORT void inworld_IntentMatcherConfig_delete(inworld_IntentMatcherConfig* carg1);

SWIGIMPORT void inworld_IntentMatcherInterface_delete(inworld_IntentMatcherInterface* carg1);

SWIGIMPORT bool inworld_IntentMatcherInterface_is_valid(inworld_IntentMatcherInterface* carg1);

SWIGIMPORT inworld_StatusOr_vector_IntentMatch* inworld_IntentMatcherInterface_MatchIntents(inworld_IntentMatcherInterface* carg1, const char * carg2);

SWIGIMPORT void inworld_IntentMatcherCreationConfig_matcher_config_set(inworld_IntentMatcherCreationConfig* carg1, inworld_IntentMatcherConfig* carg2);

SWIGIMPORT inworld_IntentMatcherConfig* inworld_IntentMatcherCreationConfig_matcher_config_get(inworld_IntentMatcherCreationConfig* carg1);

SWIGIMPORT void inworld_IntentMatcherCreationConfig_compiled_intents_set(inworld_IntentMatcherCreationConfig* carg1, inworld_vector_CompiledIntent* carg2);

SWIGIMPORT inworld_vector_CompiledIntent* inworld_IntentMatcherCreationConfig_compiled_intents_get(inworld_IntentMatcherCreationConfig* carg1);

SWIGIMPORT inworld_IntentMatcherCreationConfig* inworld_IntentMatcherCreationConfig_new();

SWIGIMPORT inworld_IntentMatcherCreationConfig* inworld_IntentMatcherCreationConfig_copy(inworld_IntentMatcherCreationConfig* carg1);

SWIGIMPORT void inworld_IntentMatcherCreationConfig_delete(inworld_IntentMatcherCreationConfig* carg1);

SWIGIMPORT void inworld_IntentMatcherFactory_delete(inworld_IntentMatcherFactory* carg1);

SWIGIMPORT inworld_StatusOr_IntentMatcherInterface* inworld_IntentMatcherFactory_CreateIntentMatcher_std_shared_ptr_Sl_inworld_TextEmbedderInterface_SS_const_Sg__std_shared_ptr_Sl_inworld_LLMInterface_SS_const_Sg__rcinworld_IntentMatcherCreationConfig(inworld_IntentMatcherFactory* carg1, inworld_TextEmbedderInterface* carg2, inworld_LLMInterface* carg3, inworld_IntentMatcherCreationConfig* carg4);

SWIGIMPORT inworld_StatusOr_IntentMatcherInterface* inworld_IntentMatcherFactory_CreateIntentMatcher_std_shared_ptr_Sl_inworld_TextEmbedderInterface_SS_const_Sg__rcinworld_IntentMatcherCreationConfig(inworld_IntentMatcherFactory* carg1, inworld_TextEmbedderInterface* carg2, inworld_IntentMatcherCreationConfig* carg3);

SWIGIMPORT inworld_StatusOr_IntentMatcherInterface* inworld_IntentMatcherFactory_CreateIntentMatcher_std_shared_ptr_Sl_inworld_LLMInterface_SS_const_Sg__rcinworld_IntentMatcherCreationConfig(inworld_IntentMatcherFactory* carg1, inworld_LLMInterface* carg2, inworld_IntentMatcherCreationConfig* carg3);

SWIGIMPORT inworld_IntentMatcherFactory* inworld_IntentMatcherFactory_new();

SWIGIMPORT inworld_IntentMatcherFactory* inworld_IntentMatcherFactory_copy(inworld_IntentMatcherFactory* carg1);

SWIGIMPORT void inworld_KeywordGroup_name_set(inworld_KeywordGroup* carg1, const char * carg2);

SWIGIMPORT const char * inworld_KeywordGroup_name_get(inworld_KeywordGroup* carg1);

SWIGIMPORT void inworld_KeywordGroup_keywords_set(inworld_KeywordGroup* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_KeywordGroup_keywords_get(inworld_KeywordGroup* carg1);

SWIGIMPORT inworld_KeywordGroup* inworld_KeywordGroup_new();

SWIGIMPORT inworld_KeywordGroup* inworld_KeywordGroup_copy(inworld_KeywordGroup* carg1);

SWIGIMPORT void inworld_KeywordGroup_delete(inworld_KeywordGroup* carg1);

SWIGIMPORT void inworld_KeywordMatch_group_name_set(inworld_KeywordMatch* carg1, const char * carg2);

SWIGIMPORT const char * inworld_KeywordMatch_group_name_get(inworld_KeywordMatch* carg1);

SWIGIMPORT void inworld_KeywordMatch_keyword_set(inworld_KeywordMatch* carg1, const char * carg2);

SWIGIMPORT const char * inworld_KeywordMatch_keyword_get(inworld_KeywordMatch* carg1);

SWIGIMPORT inworld_KeywordMatch* inworld_KeywordMatch_new();

SWIGIMPORT inworld_KeywordMatch* inworld_KeywordMatch_copy(inworld_KeywordMatch* carg1);

SWIGIMPORT void inworld_KeywordMatch_delete(inworld_KeywordMatch* carg1);

SWIGIMPORT void inworld_KeywordMatcherResponse_matches_set(inworld_KeywordMatcherResponse* carg1, inworld_vector_KeywordMatch* carg2);

SWIGIMPORT inworld_vector_KeywordMatch* inworld_KeywordMatcherResponse_matches_get(inworld_KeywordMatcherResponse* carg1);

SWIGIMPORT bool inworld_KeywordMatcherResponse_HasMatches(inworld_KeywordMatcherResponse* carg1);

SWIGIMPORT inworld_KeywordMatcherResponse* inworld_KeywordMatcherResponse_new();

SWIGIMPORT inworld_KeywordMatcherResponse* inworld_KeywordMatcherResponse_copy(inworld_KeywordMatcherResponse* carg1);

SWIGIMPORT void inworld_KeywordMatcherResponse_delete(inworld_KeywordMatcherResponse* carg1);

SWIGIMPORT void inworld_KeywordMatcherInterface_delete(inworld_KeywordMatcherInterface* carg1);

SWIGIMPORT bool inworld_KeywordMatcherInterface_is_valid(inworld_KeywordMatcherInterface* carg1);

SWIGIMPORT inworld_StatusOr_KeywordMatcherResponse* inworld_KeywordMatcherInterface_MatchKeywords(inworld_KeywordMatcherInterface* carg1, const char * carg2);

SWIGIMPORT void inworld_KeywordMatcherFactory_delete(inworld_KeywordMatcherFactory* carg1);

SWIGIMPORT inworld_StatusOr_KeywordMatcherInterface* inworld_KeywordMatcherFactory_CreateKeywordMatcher(inworld_KeywordMatcherFactory* carg1, inworld_vector_KeywordGroup* carg2);

SWIGIMPORT inworld_KeywordMatcherFactory* inworld_KeywordMatcherFactory_new();

SWIGIMPORT inworld_KeywordMatcherFactory* inworld_KeywordMatcherFactory_copy(inworld_KeywordMatcherFactory* carg1);

SWIGIMPORT void inworld_DictionaryRule_name_set(inworld_DictionaryRule* carg1, const char * carg2);

SWIGIMPORT const char * inworld_DictionaryRule_name_get(inworld_DictionaryRule* carg1);

SWIGIMPORT void inworld_DictionaryRule_display_name_set(inworld_DictionaryRule* carg1, const char * carg2);

SWIGIMPORT const char * inworld_DictionaryRule_display_name_get(inworld_DictionaryRule* carg1);

SWIGIMPORT void inworld_DictionaryRule_synonyms_set(inworld_DictionaryRule* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_DictionaryRule_synonyms_get(inworld_DictionaryRule* carg1);

SWIGIMPORT inworld_DictionaryRule* inworld_DictionaryRule_new();

SWIGIMPORT inworld_DictionaryRule* inworld_DictionaryRule_copy(inworld_DictionaryRule* carg1);

SWIGIMPORT void inworld_DictionaryRule_delete(inworld_DictionaryRule* carg1);

SWIGIMPORT void inworld_Entity_name_set(inworld_Entity* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Entity_name_get(inworld_Entity* carg1);

SWIGIMPORT void inworld_Entity_rules_set(inworld_Entity* carg1, inworld_vector_DictionaryRule* carg2);

SWIGIMPORT inworld_vector_DictionaryRule* inworld_Entity_rules_get(inworld_Entity* carg1);

SWIGIMPORT inworld_Entity* inworld_Entity_new();

SWIGIMPORT inworld_Entity* inworld_Entity_copy(inworld_Entity* carg1);

SWIGIMPORT void inworld_Entity_delete(inworld_Entity* carg1);

SWIGIMPORT void inworld_EntityMatch_entity_name_set(inworld_EntityMatch* carg1, const char * carg2);

SWIGIMPORT const char * inworld_EntityMatch_entity_name_get(inworld_EntityMatch* carg1);

SWIGIMPORT void inworld_EntityMatch_rule_name_set(inworld_EntityMatch* carg1, const char * carg2);

SWIGIMPORT const char * inworld_EntityMatch_rule_name_get(inworld_EntityMatch* carg1);

SWIGIMPORT void inworld_EntityMatch_text_set(inworld_EntityMatch* carg1, const char * carg2);

SWIGIMPORT const char * inworld_EntityMatch_text_get(inworld_EntityMatch* carg1);

SWIGIMPORT inworld_EntityMatch* inworld_EntityMatch_new();

SWIGIMPORT inworld_EntityMatch* inworld_EntityMatch_copy(inworld_EntityMatch* carg1);

SWIGIMPORT void inworld_EntityMatch_delete(inworld_EntityMatch* carg1);

SWIGIMPORT void inworld_NERInterface_delete(inworld_NERInterface* carg1);

SWIGIMPORT inworld_StatusOr_vector_EntityMatch* inworld_NERInterface_ExtractEntities(inworld_NERInterface* carg1, const char * carg2);

SWIGIMPORT bool inworld_NERInterface_is_valid(inworld_NERInterface* carg1);

SWIGIMPORT void inworld_NERCreationConfig_entities_set(inworld_NERCreationConfig* carg1, inworld_vector_Entity* carg2);

SWIGIMPORT inworld_vector_Entity* inworld_NERCreationConfig_entities_get(inworld_NERCreationConfig* carg1);

SWIGIMPORT inworld_NERCreationConfig* inworld_NERCreationConfig_new();

SWIGIMPORT inworld_NERCreationConfig* inworld_NERCreationConfig_copy(inworld_NERCreationConfig* carg1);

SWIGIMPORT void inworld_NERCreationConfig_delete(inworld_NERCreationConfig* carg1);

SWIGIMPORT inworld_StatusOr_NERInterface* inworld_NERFactory_CreateNER(inworld_NERCreationConfig* carg1);

SWIGIMPORT inworld_NERFactory* inworld_NERFactory_new();

SWIGIMPORT inworld_NERFactory* inworld_NERFactory_copy(inworld_NERFactory* carg1);

SWIGIMPORT void inworld_NERFactory_delete(inworld_NERFactory* carg1);

SWIGIMPORT inworld_VectorClassThreshold* inworld_VectorClassThreshold_new();

SWIGIMPORT inworld_VectorClassThreshold* inworld_VectorClassThreshold_copy(inworld_VectorClassThreshold* carg1);

SWIGIMPORT size_t inworld_VectorClassThreshold_size(inworld_VectorClassThreshold* carg1);

SWIGIMPORT size_t inworld_VectorClassThreshold_capacity(inworld_VectorClassThreshold* carg1);

SWIGIMPORT void inworld_VectorClassThreshold_reserve(inworld_VectorClassThreshold* carg1, size_t carg2);

SWIGIMPORT bool inworld_VectorClassThreshold_empty(inworld_VectorClassThreshold* carg1);

SWIGIMPORT void inworld_VectorClassThreshold_clear(inworld_VectorClassThreshold* carg1);

SWIGIMPORT void inworld_VectorClassThreshold_push_back(inworld_VectorClassThreshold* carg1, inworld_ClassThreshold* carg2);

SWIGIMPORT inworld_ClassThreshold* inworld_VectorClassThreshold_get(inworld_VectorClassThreshold* carg1, int carg2);

SWIGIMPORT void inworld_VectorClassThreshold_set(inworld_VectorClassThreshold* carg1, int carg2, inworld_ClassThreshold* carg3);

SWIGIMPORT void inworld_VectorClassThreshold_delete(inworld_VectorClassThreshold* carg1);

SWIGIMPORT inworld_TextClassifierResponseStatusOr* inworld_TextClassifierResponseStatusOr_new();

SWIGIMPORT inworld_TextClassifierResponseStatusOr* inworld_TextClassifierResponseStatusOr_new_rcinworld_TextClassifierResponse(inworld_TextClassifierResponse* carg1);

SWIGIMPORT inworld_TextClassifierResponseStatusOr* inworld_TextClassifierResponseStatusOr_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_TextClassifierResponseStatusOr_ok(inworld_TextClassifierResponseStatusOr* carg1);

SWIGIMPORT inworld_Status* inworld_TextClassifierResponseStatusOr_status(inworld_TextClassifierResponseStatusOr* carg1);

SWIGIMPORT inworld_TextClassifierResponse* inworld_TextClassifierResponseStatusOr_value(inworld_TextClassifierResponseStatusOr* carg1);

SWIGIMPORT inworld_TextClassifierResponseStatusOr* inworld_TextClassifierResponseStatusOr_copy(inworld_TextClassifierResponseStatusOr* carg1);

SWIGIMPORT void inworld_TextClassifierResponseStatusOr_delete(inworld_TextClassifierResponseStatusOr* carg1);

SWIGIMPORT void inworld_ClassThreshold_class_label_set(inworld_ClassThreshold* carg1, const char * carg2);

SWIGIMPORT const char * inworld_ClassThreshold_class_label_get(inworld_ClassThreshold* carg1);

SWIGIMPORT void inworld_ClassThreshold_threshold_set(inworld_ClassThreshold* carg1, float carg2);

SWIGIMPORT float inworld_ClassThreshold_threshold_get(inworld_ClassThreshold* carg1);

SWIGIMPORT inworld_ClassThreshold* inworld_ClassThreshold_new();

SWIGIMPORT inworld_ClassThreshold* inworld_ClassThreshold_copy(inworld_ClassThreshold* carg1);

SWIGIMPORT void inworld_ClassThreshold_delete(inworld_ClassThreshold* carg1);

SWIGIMPORT void inworld_TextClassifierConfig_classes_set(inworld_TextClassifierConfig* carg1, inworld_VectorClassThreshold* carg2);

SWIGIMPORT inworld_VectorClassThreshold* inworld_TextClassifierConfig_classes_get(inworld_TextClassifierConfig* carg1);

SWIGIMPORT inworld_TextClassifierConfig* inworld_TextClassifierConfig_new();

SWIGIMPORT inworld_TextClassifierConfig* inworld_TextClassifierConfig_copy(inworld_TextClassifierConfig* carg1);

SWIGIMPORT void inworld_TextClassifierConfig_delete(inworld_TextClassifierConfig* carg1);

SWIGIMPORT void inworld_TextClassifierResponse_classes_set(inworld_TextClassifierResponse* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_TextClassifierResponse_classes_get(inworld_TextClassifierResponse* carg1);

SWIGIMPORT bool inworld_TextClassifierResponse_HasResults(inworld_TextClassifierResponse* carg1);

SWIGIMPORT inworld_TextClassifierResponse* inworld_TextClassifierResponse_new();

SWIGIMPORT inworld_TextClassifierResponse* inworld_TextClassifierResponse_copy(inworld_TextClassifierResponse* carg1);

SWIGIMPORT void inworld_TextClassifierResponse_delete(inworld_TextClassifierResponse* carg1);

SWIGIMPORT void inworld_TextClassifierInterface_delete(inworld_TextClassifierInterface* carg1);

SWIGIMPORT inworld_TextClassifierResponseStatusOr* inworld_TextClassifierInterface_ClassifyText_rcstd_string(inworld_TextClassifierInterface* carg1, const char * carg2);

SWIGIMPORT inworld_TextClassifierResponseStatusOr* inworld_TextClassifierInterface_ClassifyText_rcstd_string_rcinworld_TextClassifierConfig(inworld_TextClassifierInterface* carg1, const char * carg2, inworld_TextClassifierConfig* carg3);

SWIGIMPORT inworld_TextClassifierInterfaceSharedPtrStatusOr* inworld_TextClassifierInterfaceSharedPtrStatusOr_new();

SWIGIMPORT inworld_TextClassifierInterfaceSharedPtrStatusOr* inworld_TextClassifierInterfaceSharedPtrStatusOr_new_rcstd_shared_ptr_Sl_inworld_TextClassifierInterface_Sg_(inworld_TextClassifierInterface* carg1);

SWIGIMPORT inworld_TextClassifierInterfaceSharedPtrStatusOr* inworld_TextClassifierInterfaceSharedPtrStatusOr_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_TextClassifierInterfaceSharedPtrStatusOr_ok(inworld_TextClassifierInterfaceSharedPtrStatusOr* carg1);

SWIGIMPORT inworld_Status* inworld_TextClassifierInterfaceSharedPtrStatusOr_status(inworld_TextClassifierInterfaceSharedPtrStatusOr* carg1);

SWIGIMPORT inworld_TextClassifierInterface* inworld_TextClassifierInterfaceSharedPtrStatusOr_value(inworld_TextClassifierInterfaceSharedPtrStatusOr* carg1);

SWIGIMPORT inworld_TextClassifierInterfaceSharedPtrStatusOr* inworld_TextClassifierInterfaceSharedPtrStatusOr_copy(inworld_TextClassifierInterfaceSharedPtrStatusOr* carg1);

SWIGIMPORT void inworld_TextClassifierInterfaceSharedPtrStatusOr_delete(inworld_TextClassifierInterfaceSharedPtrStatusOr* carg1);

SWIGIMPORT void inworld_TextClassifierCreationConfig_model_weights_path_set(inworld_TextClassifierCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TextClassifierCreationConfig_model_weights_path_get(inworld_TextClassifierCreationConfig* carg1);

SWIGIMPORT void inworld_TextClassifierCreationConfig_supported_classes_set(inworld_TextClassifierCreationConfig* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_TextClassifierCreationConfig_supported_classes_get(inworld_TextClassifierCreationConfig* carg1);

SWIGIMPORT inworld_TextClassifierCreationConfig* inworld_TextClassifierCreationConfig_new();

SWIGIMPORT inworld_TextClassifierCreationConfig* inworld_TextClassifierCreationConfig_copy(inworld_TextClassifierCreationConfig* carg1);

SWIGIMPORT void inworld_TextClassifierCreationConfig_delete(inworld_TextClassifierCreationConfig* carg1);

SWIGIMPORT void inworld_TextClassifierFactory_delete(inworld_TextClassifierFactory* carg1);

SWIGIMPORT inworld_TextClassifierInterfaceSharedPtrStatusOr* inworld_TextClassifierFactory_CreateTextClassifier(inworld_TextClassifierFactory* carg1, inworld_TextEmbedderInterface* carg2, inworld_TextClassifierCreationConfig* carg3);

SWIGIMPORT inworld_TextClassifierFactory* inworld_TextClassifierFactory_new();

SWIGIMPORT inworld_TextClassifierFactory* inworld_TextClassifierFactory_copy(inworld_TextClassifierFactory* carg1);

SWIGIMPORT void inworld_TopicThreshold_topic_name_set(inworld_TopicThreshold* carg1, enum inworld_TopicName carg2);

SWIGIMPORT enum inworld_TopicName inworld_TopicThreshold_topic_name_get(inworld_TopicThreshold* carg1);

SWIGIMPORT void inworld_TopicThreshold_threshold_set(inworld_TopicThreshold* carg1, float carg2);

SWIGIMPORT float inworld_TopicThreshold_threshold_get(inworld_TopicThreshold* carg1);

SWIGIMPORT inworld_TopicThreshold* inworld_TopicThreshold_new();

SWIGIMPORT inworld_TopicThreshold* inworld_TopicThreshold_copy(inworld_TopicThreshold* carg1);

SWIGIMPORT void inworld_TopicThreshold_delete(inworld_TopicThreshold* carg1);

SWIGIMPORT void inworld_SafetyConfig_forbidden_topics_set(inworld_SafetyConfig* carg1, inworld_vector_TopicThreshold* carg2);

SWIGIMPORT inworld_vector_TopicThreshold* inworld_SafetyConfig_forbidden_topics_get(inworld_SafetyConfig* carg1);

SWIGIMPORT inworld_SafetyConfig* inworld_SafetyConfig_new();

SWIGIMPORT inworld_SafetyConfig* inworld_SafetyConfig_copy(inworld_SafetyConfig* carg1);

SWIGIMPORT void inworld_SafetyConfig_delete(inworld_SafetyConfig* carg1);

SWIGIMPORT void inworld_DetectedTopic_topic_name_set(inworld_DetectedTopic* carg1, enum inworld_TopicName carg2);

SWIGIMPORT enum inworld_TopicName inworld_DetectedTopic_topic_name_get(inworld_DetectedTopic* carg1);

SWIGIMPORT void inworld_DetectedTopic_confidence_set(inworld_DetectedTopic* carg1, float carg2);

SWIGIMPORT float inworld_DetectedTopic_confidence_get(inworld_DetectedTopic* carg1);

SWIGIMPORT inworld_DetectedTopic* inworld_DetectedTopic_new();

SWIGIMPORT inworld_DetectedTopic* inworld_DetectedTopic_copy(inworld_DetectedTopic* carg1);

SWIGIMPORT void inworld_DetectedTopic_delete(inworld_DetectedTopic* carg1);

SWIGIMPORT void inworld_CheckSafetyResponse_is_safe_set(inworld_CheckSafetyResponse* carg1, bool carg2);

SWIGIMPORT bool inworld_CheckSafetyResponse_is_safe_get(inworld_CheckSafetyResponse* carg1);

SWIGIMPORT void inworld_CheckSafetyResponse_detected_topics_set(inworld_CheckSafetyResponse* carg1, inworld_vector_DetectedTopic* carg2);

SWIGIMPORT inworld_vector_DetectedTopic* inworld_CheckSafetyResponse_detected_topics_get(inworld_CheckSafetyResponse* carg1);

SWIGIMPORT inworld_CheckSafetyResponse* inworld_CheckSafetyResponse_new();

SWIGIMPORT inworld_CheckSafetyResponse* inworld_CheckSafetyResponse_copy(inworld_CheckSafetyResponse* carg1);

SWIGIMPORT void inworld_CheckSafetyResponse_delete(inworld_CheckSafetyResponse* carg1);

SWIGIMPORT void inworld_SafetyCheckerInterface_delete(inworld_SafetyCheckerInterface* carg1);

SWIGIMPORT bool inworld_SafetyCheckerInterface_is_valid(inworld_SafetyCheckerInterface* carg1);

SWIGIMPORT inworld_StatusOr_CheckSafetyResponse* inworld_SafetyCheckerInterface_CheckSafety_rcstd_string(inworld_SafetyCheckerInterface* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_CheckSafetyResponse* inworld_SafetyCheckerInterface_CheckSafety_rcstd_string_rcinworld_SafetyConfig(inworld_SafetyCheckerInterface* carg1, const char * carg2, inworld_SafetyConfig* carg3);

SWIGIMPORT void inworld_SafetyCheckerCreationConfig_model_weights_path_set(inworld_SafetyCheckerCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_SafetyCheckerCreationConfig_model_weights_path_get(inworld_SafetyCheckerCreationConfig* carg1);

SWIGIMPORT inworld_SafetyCheckerCreationConfig* inworld_SafetyCheckerCreationConfig_new();

SWIGIMPORT inworld_SafetyCheckerCreationConfig* inworld_SafetyCheckerCreationConfig_copy(inworld_SafetyCheckerCreationConfig* carg1);

SWIGIMPORT void inworld_SafetyCheckerCreationConfig_delete(inworld_SafetyCheckerCreationConfig* carg1);

SWIGIMPORT void inworld_SafetyCheckerFactory_delete(inworld_SafetyCheckerFactory* carg1);

SWIGIMPORT inworld_StatusOr_SafetyCheckerInterface* inworld_SafetyCheckerFactory_CreateSafetyChecker(inworld_SafetyCheckerFactory* carg1, inworld_TextEmbedderInterface* carg2, inworld_SafetyCheckerCreationConfig* carg3);

SWIGIMPORT inworld_SafetyCheckerFactory* inworld_SafetyCheckerFactory_new();

SWIGIMPORT inworld_SafetyCheckerFactory* inworld_SafetyCheckerFactory_copy(inworld_SafetyCheckerFactory* carg1);

SWIGIMPORT inworld_StatusOr_EmojiRemover* inworld_EmojiRemover_Create(inworld_InputStream_string* carg1);

SWIGIMPORT void inworld_EmojiRemover_delete(inworld_EmojiRemover* carg1);

SWIGIMPORT bool inworld_EmojiRemover_HasNext(inworld_EmojiRemover* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_EmojiRemover_Read(inworld_EmojiRemover* carg1);

SWIGIMPORT void inworld_EmojiRemover_Cancel(inworld_EmojiRemover* carg1);

SWIGIMPORT bool inworld_EmojiRemover_is_valid(inworld_EmojiRemover* carg1);

SWIGIMPORT void inworld_SentenceStreamCreationConfig_min_chunk_length_set(inworld_SentenceStreamCreationConfig* carg1, inworld_optional_int* carg2);

SWIGIMPORT inworld_optional_int* inworld_SentenceStreamCreationConfig_min_chunk_length_get(inworld_SentenceStreamCreationConfig* carg1);

SWIGIMPORT inworld_SentenceStreamCreationConfig* inworld_SentenceStreamCreationConfig_new();

SWIGIMPORT inworld_SentenceStreamCreationConfig* inworld_SentenceStreamCreationConfig_copy(inworld_SentenceStreamCreationConfig* carg1);

SWIGIMPORT void inworld_SentenceStreamCreationConfig_delete(inworld_SentenceStreamCreationConfig* carg1);

SWIGIMPORT inworld_StatusOr_SentenceStream* inworld_SentenceStream_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg_(inworld_InputStream_string* carg1);

SWIGIMPORT inworld_StatusOr_SentenceStream* inworld_SentenceStream_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_SentenceStreamCreationConfig(inworld_InputStream_string* carg1, inworld_SentenceStreamCreationConfig* carg2);

SWIGIMPORT void inworld_SentenceStream_delete(inworld_SentenceStream* carg1);

SWIGIMPORT bool inworld_SentenceStream_HasNext(inworld_SentenceStream* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_SentenceStream_Read(inworld_SentenceStream* carg1);

SWIGIMPORT void inworld_SentenceStream_Cancel(inworld_SentenceStream* carg1);

SWIGIMPORT bool inworld_SentenceStream_is_valid(inworld_SentenceStream* carg1);

SWIGIMPORT inworld_StatusOr_SubstringRemover* inworld_SubstringRemover_Create(inworld_InputStream_string* carg1, inworld_vector_string* carg2);

SWIGIMPORT void inworld_SubstringRemover_delete(inworld_SubstringRemover* carg1);

SWIGIMPORT bool inworld_SubstringRemover_HasNext(inworld_SubstringRemover* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_SubstringRemover_Read(inworld_SubstringRemover* carg1);

SWIGIMPORT void inworld_SubstringRemover_Cancel(inworld_SubstringRemover* carg1);

SWIGIMPORT bool inworld_SubstringRemover_is_valid(inworld_SubstringRemover* carg1);

SWIGIMPORT inworld_StatusOr_TextInBracketsRemover* inworld_TextInBracketsRemover_Create(inworld_InputStream_string* carg1);

SWIGIMPORT void inworld_TextInBracketsRemover_delete(inworld_TextInBracketsRemover* carg1);

SWIGIMPORT bool inworld_TextInBracketsRemover_HasNext(inworld_TextInBracketsRemover* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_TextInBracketsRemover_Read(inworld_TextInBracketsRemover* carg1);

SWIGIMPORT void inworld_TextInBracketsRemover_Cancel(inworld_TextInBracketsRemover* carg1);

SWIGIMPORT bool inworld_TextInBracketsRemover_is_valid(inworld_TextInBracketsRemover* carg1);

SWIGIMPORT inworld_optional_LocalSTTConfig* inworld_optional_LocalSTTConfig_new();

SWIGIMPORT inworld_optional_LocalSTTConfig* inworld_optional_LocalSTTConfig_new_rcinworld_LocalSTTConfig(inworld_LocalSTTConfig* carg1);

SWIGIMPORT inworld_optional_LocalSTTConfig* inworld_optional_LocalSTTConfig_copy(inworld_optional_LocalSTTConfig* carg1);

SWIGIMPORT void inworld_optional_LocalSTTConfig_delete(inworld_optional_LocalSTTConfig* carg1);

SWIGIMPORT bool inworld_optional_LocalSTTConfig_has_value(inworld_optional_LocalSTTConfig* carg1);

SWIGIMPORT inworld_LocalSTTConfig* inworld_optional_LocalSTTConfig_value(inworld_optional_LocalSTTConfig* carg1);

SWIGIMPORT inworld_LocalSTTConfig* inworld_optional_LocalSTTConfig_valueConst(inworld_optional_LocalSTTConfig* carg1);

SWIGIMPORT inworld_LocalSTTConfig* inworld_optional_LocalSTTConfig_value_or(inworld_optional_LocalSTTConfig* carg1, inworld_LocalSTTConfig* carg2);

SWIGIMPORT void inworld_optional_LocalSTTConfig_reset(inworld_optional_LocalSTTConfig* carg1);

SWIGIMPORT inworld_LocalSTTConfig* inworld_optional_LocalSTTConfig_get(inworld_optional_LocalSTTConfig* carg1);

SWIGIMPORT inworld_LocalSTTConfig* inworld_optional_LocalSTTConfig_getConst(inworld_optional_LocalSTTConfig* carg1);

SWIGIMPORT inworld_LocalSTTConfig* inworld_optional_LocalSTTConfig_get_value(inworld_optional_LocalSTTConfig* carg1);

SWIGIMPORT void inworld_optional_LocalSTTConfig_set_value(inworld_optional_LocalSTTConfig* carg1, inworld_LocalSTTConfig* carg2);

SWIGIMPORT inworld_optional_RemoteSTTConfig* inworld_optional_RemoteSTTConfig_new();

SWIGIMPORT inworld_optional_RemoteSTTConfig* inworld_optional_RemoteSTTConfig_new_rcinworld_RemoteSTTConfig(inworld_RemoteSTTConfig* carg1);

SWIGIMPORT inworld_optional_RemoteSTTConfig* inworld_optional_RemoteSTTConfig_copy(inworld_optional_RemoteSTTConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteSTTConfig_delete(inworld_optional_RemoteSTTConfig* carg1);

SWIGIMPORT bool inworld_optional_RemoteSTTConfig_has_value(inworld_optional_RemoteSTTConfig* carg1);

SWIGIMPORT inworld_RemoteSTTConfig* inworld_optional_RemoteSTTConfig_value(inworld_optional_RemoteSTTConfig* carg1);

SWIGIMPORT inworld_RemoteSTTConfig* inworld_optional_RemoteSTTConfig_valueConst(inworld_optional_RemoteSTTConfig* carg1);

SWIGIMPORT inworld_RemoteSTTConfig* inworld_optional_RemoteSTTConfig_value_or(inworld_optional_RemoteSTTConfig* carg1, inworld_RemoteSTTConfig* carg2);

SWIGIMPORT void inworld_optional_RemoteSTTConfig_reset(inworld_optional_RemoteSTTConfig* carg1);

SWIGIMPORT inworld_RemoteSTTConfig* inworld_optional_RemoteSTTConfig_get(inworld_optional_RemoteSTTConfig* carg1);

SWIGIMPORT inworld_RemoteSTTConfig* inworld_optional_RemoteSTTConfig_getConst(inworld_optional_RemoteSTTConfig* carg1);

SWIGIMPORT inworld_RemoteSTTConfig* inworld_optional_RemoteSTTConfig_get_value(inworld_optional_RemoteSTTConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteSTTConfig_set_value(inworld_optional_RemoteSTTConfig* carg1, inworld_RemoteSTTConfig* carg2);

SWIGIMPORT inworld_optional_Language* inworld_optional_Language_new();

SWIGIMPORT inworld_optional_Language* inworld_optional_Language_new_rcinworld_library_Language(inworld_Language* carg1);

SWIGIMPORT inworld_optional_Language* inworld_optional_Language_copy(inworld_optional_Language* carg1);

SWIGIMPORT void inworld_optional_Language_delete(inworld_optional_Language* carg1);

SWIGIMPORT bool inworld_optional_Language_has_value(inworld_optional_Language* carg1);

SWIGIMPORT inworld_Language* inworld_optional_Language_value(inworld_optional_Language* carg1);

SWIGIMPORT inworld_Language* inworld_optional_Language_valueConst(inworld_optional_Language* carg1);

SWIGIMPORT inworld_Language* inworld_optional_Language_value_or(inworld_optional_Language* carg1, inworld_Language* carg2);

SWIGIMPORT void inworld_optional_Language_reset(inworld_optional_Language* carg1);

SWIGIMPORT inworld_Language* inworld_optional_Language_get(inworld_optional_Language* carg1);

SWIGIMPORT inworld_Language* inworld_optional_Language_getConst(inworld_optional_Language* carg1);

SWIGIMPORT inworld_Language* inworld_optional_Language_get_value(inworld_optional_Language* carg1);

SWIGIMPORT void inworld_optional_Language_set_value(inworld_optional_Language* carg1, inworld_Language* carg2);

SWIGIMPORT void inworld_LocalSTTConfig_model_path_set(inworld_LocalSTTConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LocalSTTConfig_model_path_get(inworld_LocalSTTConfig* carg1);

SWIGIMPORT void inworld_LocalSTTConfig_device_set(inworld_LocalSTTConfig* carg1, inworld_Device* carg2);

SWIGIMPORT inworld_Device* inworld_LocalSTTConfig_device_get(inworld_LocalSTTConfig* carg1);

SWIGIMPORT void inworld_LocalSTTConfig_default_config_set(inworld_LocalSTTConfig* carg1, inworld_SpeechRecognitionConfig* carg2);

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_LocalSTTConfig_default_config_get(inworld_LocalSTTConfig* carg1);

SWIGIMPORT inworld_LocalSTTConfig* inworld_LocalSTTConfig_new();

SWIGIMPORT inworld_LocalSTTConfig* inworld_LocalSTTConfig_copy(inworld_LocalSTTConfig* carg1);

SWIGIMPORT void inworld_LocalSTTConfig_delete(inworld_LocalSTTConfig* carg1);

SWIGIMPORT void inworld_RemoteSTTConfig_api_key_set(inworld_RemoteSTTConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RemoteSTTConfig_api_key_get(inworld_RemoteSTTConfig* carg1);

SWIGIMPORT void inworld_RemoteSTTConfig_default_config_set(inworld_RemoteSTTConfig* carg1, inworld_SpeechRecognitionConfig* carg2);

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_RemoteSTTConfig_default_config_get(inworld_RemoteSTTConfig* carg1);

SWIGIMPORT inworld_RemoteSTTConfig* inworld_RemoteSTTConfig_new();

SWIGIMPORT inworld_RemoteSTTConfig* inworld_RemoteSTTConfig_copy(inworld_RemoteSTTConfig* carg1);

SWIGIMPORT void inworld_RemoteSTTConfig_delete(inworld_RemoteSTTConfig* carg1);

SWIGIMPORT bool inworld_STTCreationConfig_has_local_config(inworld_STTCreationConfig* carg1);

SWIGIMPORT bool inworld_STTCreationConfig_has_remote_config(inworld_STTCreationConfig* carg1);

SWIGIMPORT inworld_optional_LocalSTTConfig* inworld_STTCreationConfig_get_local_config(inworld_STTCreationConfig* carg1);

SWIGIMPORT inworld_optional_RemoteSTTConfig* inworld_STTCreationConfig_get_remote_config(inworld_STTCreationConfig* carg1);

SWIGIMPORT void inworld_STTCreationConfig_set_local_config(inworld_STTCreationConfig* carg1, inworld_LocalSTTConfig* carg2);

SWIGIMPORT void inworld_STTCreationConfig_set_remote_config(inworld_STTCreationConfig* carg1, inworld_RemoteSTTConfig* carg2);

SWIGIMPORT inworld_STTCreationConfig* inworld_STTCreationConfig_new();

SWIGIMPORT inworld_STTCreationConfig* inworld_STTCreationConfig_copy(inworld_STTCreationConfig* carg1);

SWIGIMPORT void inworld_STTCreationConfig_delete(inworld_STTCreationConfig* carg1);

SWIGIMPORT void inworld_STTFactory_delete(inworld_STTFactory* carg1);

SWIGIMPORT inworld_StatusOr_STTInterface* inworld_STTFactory_CreateSTT_rcinworld_LocalSTTConfig(inworld_STTFactory* carg1, inworld_LocalSTTConfig* carg2);

SWIGIMPORT inworld_StatusOr_STTInterface* inworld_STTFactory_CreateSTT_rcinworld_RemoteSTTConfig(inworld_STTFactory* carg1, inworld_RemoteSTTConfig* carg2);

SWIGIMPORT inworld_STTFactory* inworld_STTFactory_new();

SWIGIMPORT inworld_STTFactory* inworld_STTFactory_copy(inworld_STTFactory* carg1);

SWIGIMPORT void inworld_StreamSpeechRecognitionConfig_speech_config_set(inworld_StreamSpeechRecognitionConfig* carg1, inworld_SpeechRecognitionConfig* carg2);

SWIGIMPORT inworld_SpeechRecognitionConfig* inworld_StreamSpeechRecognitionConfig_speech_config_get(inworld_StreamSpeechRecognitionConfig* carg1);

SWIGIMPORT void inworld_StreamSpeechRecognitionConfig_silence_threshold_ms_set(inworld_StreamSpeechRecognitionConfig* carg1, int carg2);

SWIGIMPORT int inworld_StreamSpeechRecognitionConfig_silence_threshold_ms_get(inworld_StreamSpeechRecognitionConfig* carg1);

SWIGIMPORT inworld_StreamSpeechRecognitionConfig* inworld_StreamSpeechRecognitionConfig_new();

SWIGIMPORT inworld_StreamSpeechRecognitionConfig* inworld_StreamSpeechRecognitionConfig_copy(inworld_StreamSpeechRecognitionConfig* carg1);

SWIGIMPORT void inworld_StreamSpeechRecognitionConfig_delete(inworld_StreamSpeechRecognitionConfig* carg1);

SWIGIMPORT void inworld_StreamingSTTInterface_delete(inworld_StreamingSTTInterface* carg1);

SWIGIMPORT bool inworld_StreamingSTTInterface_is_valid(inworld_StreamingSTTInterface* carg1);

SWIGIMPORT inworld_ModelProperties* inworld_StreamingSTTInterface_model_properties(inworld_StreamingSTTInterface* carg1);

SWIGIMPORT inworld_optional_LocalStreamingSTTConfig* inworld_optional_LocalStreamingSTTConfig_new();

SWIGIMPORT inworld_optional_LocalStreamingSTTConfig* inworld_optional_LocalStreamingSTTConfig_new_rcinworld_LocalStreamingSTTConfig(inworld_LocalStreamingSTTConfig* carg1);

SWIGIMPORT inworld_optional_LocalStreamingSTTConfig* inworld_optional_LocalStreamingSTTConfig_copy(inworld_optional_LocalStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_optional_LocalStreamingSTTConfig_delete(inworld_optional_LocalStreamingSTTConfig* carg1);

SWIGIMPORT bool inworld_optional_LocalStreamingSTTConfig_has_value(inworld_optional_LocalStreamingSTTConfig* carg1);

SWIGIMPORT inworld_LocalStreamingSTTConfig* inworld_optional_LocalStreamingSTTConfig_value(inworld_optional_LocalStreamingSTTConfig* carg1);

SWIGIMPORT inworld_LocalStreamingSTTConfig* inworld_optional_LocalStreamingSTTConfig_valueConst(inworld_optional_LocalStreamingSTTConfig* carg1);

SWIGIMPORT inworld_LocalStreamingSTTConfig* inworld_optional_LocalStreamingSTTConfig_value_or(inworld_optional_LocalStreamingSTTConfig* carg1, inworld_LocalStreamingSTTConfig* carg2);

SWIGIMPORT void inworld_optional_LocalStreamingSTTConfig_reset(inworld_optional_LocalStreamingSTTConfig* carg1);

SWIGIMPORT inworld_LocalStreamingSTTConfig* inworld_optional_LocalStreamingSTTConfig_get(inworld_optional_LocalStreamingSTTConfig* carg1);

SWIGIMPORT inworld_LocalStreamingSTTConfig* inworld_optional_LocalStreamingSTTConfig_getConst(inworld_optional_LocalStreamingSTTConfig* carg1);

SWIGIMPORT inworld_LocalStreamingSTTConfig* inworld_optional_LocalStreamingSTTConfig_get_value(inworld_optional_LocalStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_optional_LocalStreamingSTTConfig_set_value(inworld_optional_LocalStreamingSTTConfig* carg1, inworld_LocalStreamingSTTConfig* carg2);

SWIGIMPORT inworld_optional_RemoteStreamingSTTConfig* inworld_optional_RemoteStreamingSTTConfig_new();

SWIGIMPORT inworld_optional_RemoteStreamingSTTConfig* inworld_optional_RemoteStreamingSTTConfig_new_rcinworld_RemoteStreamingSTTConfig(inworld_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT inworld_optional_RemoteStreamingSTTConfig* inworld_optional_RemoteStreamingSTTConfig_copy(inworld_optional_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteStreamingSTTConfig_delete(inworld_optional_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT bool inworld_optional_RemoteStreamingSTTConfig_has_value(inworld_optional_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT inworld_RemoteStreamingSTTConfig* inworld_optional_RemoteStreamingSTTConfig_value(inworld_optional_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT inworld_RemoteStreamingSTTConfig* inworld_optional_RemoteStreamingSTTConfig_valueConst(inworld_optional_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT inworld_RemoteStreamingSTTConfig* inworld_optional_RemoteStreamingSTTConfig_value_or(inworld_optional_RemoteStreamingSTTConfig* carg1, inworld_RemoteStreamingSTTConfig* carg2);

SWIGIMPORT void inworld_optional_RemoteStreamingSTTConfig_reset(inworld_optional_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT inworld_RemoteStreamingSTTConfig* inworld_optional_RemoteStreamingSTTConfig_get(inworld_optional_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT inworld_RemoteStreamingSTTConfig* inworld_optional_RemoteStreamingSTTConfig_getConst(inworld_optional_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT inworld_RemoteStreamingSTTConfig* inworld_optional_RemoteStreamingSTTConfig_get_value(inworld_optional_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteStreamingSTTConfig_set_value(inworld_optional_RemoteStreamingSTTConfig* carg1, inworld_RemoteStreamingSTTConfig* carg2);

SWIGIMPORT void inworld_LocalStreamingSTTConfig_stt_model_path_set(inworld_LocalStreamingSTTConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LocalStreamingSTTConfig_stt_model_path_get(inworld_LocalStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_LocalStreamingSTTConfig_vad_model_path_set(inworld_LocalStreamingSTTConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LocalStreamingSTTConfig_vad_model_path_get(inworld_LocalStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_LocalStreamingSTTConfig_stt_device_set(inworld_LocalStreamingSTTConfig* carg1, inworld_Device* carg2);

SWIGIMPORT inworld_Device* inworld_LocalStreamingSTTConfig_stt_device_get(inworld_LocalStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_LocalStreamingSTTConfig_vad_device_set(inworld_LocalStreamingSTTConfig* carg1, inworld_Device* carg2);

SWIGIMPORT inworld_Device* inworld_LocalStreamingSTTConfig_vad_device_get(inworld_LocalStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_LocalStreamingSTTConfig_default_config_set(inworld_LocalStreamingSTTConfig* carg1, inworld_StreamSpeechRecognitionConfig* carg2);

SWIGIMPORT inworld_StreamSpeechRecognitionConfig* inworld_LocalStreamingSTTConfig_default_config_get(inworld_LocalStreamingSTTConfig* carg1);

SWIGIMPORT inworld_LocalStreamingSTTConfig* inworld_LocalStreamingSTTConfig_new();

SWIGIMPORT inworld_LocalStreamingSTTConfig* inworld_LocalStreamingSTTConfig_copy(inworld_LocalStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_LocalStreamingSTTConfig_delete(inworld_LocalStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_RemoteStreamingSTTConfig_api_key_set(inworld_RemoteStreamingSTTConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RemoteStreamingSTTConfig_api_key_get(inworld_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_RemoteStreamingSTTConfig_default_config_set(inworld_RemoteStreamingSTTConfig* carg1, inworld_StreamSpeechRecognitionConfig* carg2);

SWIGIMPORT inworld_StreamSpeechRecognitionConfig* inworld_RemoteStreamingSTTConfig_default_config_get(inworld_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT inworld_RemoteStreamingSTTConfig* inworld_RemoteStreamingSTTConfig_new();

SWIGIMPORT inworld_RemoteStreamingSTTConfig* inworld_RemoteStreamingSTTConfig_copy(inworld_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT void inworld_RemoteStreamingSTTConfig_delete(inworld_RemoteStreamingSTTConfig* carg1);

SWIGIMPORT bool inworld_StreamingSTTCreationConfig_has_local_config(inworld_StreamingSTTCreationConfig* carg1);

SWIGIMPORT bool inworld_StreamingSTTCreationConfig_has_remote_config(inworld_StreamingSTTCreationConfig* carg1);

SWIGIMPORT inworld_optional_LocalStreamingSTTConfig* inworld_StreamingSTTCreationConfig_get_local_config(inworld_StreamingSTTCreationConfig* carg1);

SWIGIMPORT inworld_optional_RemoteStreamingSTTConfig* inworld_StreamingSTTCreationConfig_get_remote_config(inworld_StreamingSTTCreationConfig* carg1);

SWIGIMPORT void inworld_StreamingSTTCreationConfig_set_local_config(inworld_StreamingSTTCreationConfig* carg1, inworld_LocalStreamingSTTConfig* carg2);

SWIGIMPORT void inworld_StreamingSTTCreationConfig_set_remote_config(inworld_StreamingSTTCreationConfig* carg1, inworld_RemoteStreamingSTTConfig* carg2);

SWIGIMPORT inworld_StreamingSTTCreationConfig* inworld_StreamingSTTCreationConfig_new();

SWIGIMPORT inworld_StreamingSTTCreationConfig* inworld_StreamingSTTCreationConfig_copy(inworld_StreamingSTTCreationConfig* carg1);

SWIGIMPORT void inworld_StreamingSTTCreationConfig_delete(inworld_StreamingSTTCreationConfig* carg1);

SWIGIMPORT void inworld_StreamingSTTFactory_delete(inworld_StreamingSTTFactory* carg1);

SWIGIMPORT inworld_StreamingSTTFactory* inworld_StreamingSTTFactory_new();

SWIGIMPORT inworld_StreamingSTTFactory* inworld_StreamingSTTFactory_copy(inworld_StreamingSTTFactory* carg1);

SWIGIMPORT inworld_optional_RemoteTTSConfig* inworld_optional_RemoteTTSConfig_new();

SWIGIMPORT inworld_optional_RemoteTTSConfig* inworld_optional_RemoteTTSConfig_new_rcinworld_RemoteTTSConfig(inworld_RemoteTTSConfig* carg1);

SWIGIMPORT inworld_optional_RemoteTTSConfig* inworld_optional_RemoteTTSConfig_copy(inworld_optional_RemoteTTSConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteTTSConfig_delete(inworld_optional_RemoteTTSConfig* carg1);

SWIGIMPORT bool inworld_optional_RemoteTTSConfig_has_value(inworld_optional_RemoteTTSConfig* carg1);

SWIGIMPORT inworld_RemoteTTSConfig* inworld_optional_RemoteTTSConfig_value(inworld_optional_RemoteTTSConfig* carg1);

SWIGIMPORT inworld_RemoteTTSConfig* inworld_optional_RemoteTTSConfig_valueConst(inworld_optional_RemoteTTSConfig* carg1);

SWIGIMPORT inworld_RemoteTTSConfig* inworld_optional_RemoteTTSConfig_value_or(inworld_optional_RemoteTTSConfig* carg1, inworld_RemoteTTSConfig* carg2);

SWIGIMPORT void inworld_optional_RemoteTTSConfig_reset(inworld_optional_RemoteTTSConfig* carg1);

SWIGIMPORT inworld_RemoteTTSConfig* inworld_optional_RemoteTTSConfig_get(inworld_optional_RemoteTTSConfig* carg1);

SWIGIMPORT inworld_RemoteTTSConfig* inworld_optional_RemoteTTSConfig_getConst(inworld_optional_RemoteTTSConfig* carg1);

SWIGIMPORT inworld_RemoteTTSConfig* inworld_optional_RemoteTTSConfig_get_value(inworld_optional_RemoteTTSConfig* carg1);

SWIGIMPORT void inworld_optional_RemoteTTSConfig_set_value(inworld_optional_RemoteTTSConfig* carg1, inworld_RemoteTTSConfig* carg2);

SWIGIMPORT inworld_LocalTTSConfig* inworld_LocalTTSConfig_new();

SWIGIMPORT inworld_LocalTTSConfig* inworld_LocalTTSConfig_copy(inworld_LocalTTSConfig* carg1);

SWIGIMPORT void inworld_LocalTTSConfig_delete(inworld_LocalTTSConfig* carg1);

SWIGIMPORT void inworld_RemoteTTSConfig_api_key_set(inworld_RemoteTTSConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_RemoteTTSConfig_api_key_get(inworld_RemoteTTSConfig* carg1);

SWIGIMPORT void inworld_RemoteTTSConfig_synthesis_config_set(inworld_RemoteTTSConfig* carg1, inworld_SpeechSynthesisConfig* carg2);

SWIGIMPORT inworld_SpeechSynthesisConfig* inworld_RemoteTTSConfig_synthesis_config_get(inworld_RemoteTTSConfig* carg1);

SWIGIMPORT inworld_RemoteTTSConfig* inworld_RemoteTTSConfig_new();

SWIGIMPORT inworld_RemoteTTSConfig* inworld_RemoteTTSConfig_copy(inworld_RemoteTTSConfig* carg1);

SWIGIMPORT void inworld_RemoteTTSConfig_delete(inworld_RemoteTTSConfig* carg1);

SWIGIMPORT bool inworld_TTSCreationConfig_has_remote_config(inworld_TTSCreationConfig* carg1);

SWIGIMPORT inworld_optional_RemoteTTSConfig* inworld_TTSCreationConfig_get_remote_config(inworld_TTSCreationConfig* carg1);

SWIGIMPORT void inworld_TTSCreationConfig_set_remote_config(inworld_TTSCreationConfig* carg1, inworld_RemoteTTSConfig* carg2);

SWIGIMPORT inworld_TTSCreationConfig* inworld_TTSCreationConfig_new();

SWIGIMPORT inworld_TTSCreationConfig* inworld_TTSCreationConfig_copy(inworld_TTSCreationConfig* carg1);

SWIGIMPORT void inworld_TTSCreationConfig_delete(inworld_TTSCreationConfig* carg1);

SWIGIMPORT void inworld_TTSFactory_delete(inworld_TTSFactory* carg1);

SWIGIMPORT inworld_StatusOr_TTSInterface* inworld_TTSFactory_CreateTTS(inworld_TTSFactory* carg1, inworld_RemoteTTSConfig* carg2);

SWIGIMPORT inworld_TTSFactory* inworld_TTSFactory_new();

SWIGIMPORT inworld_TTSFactory* inworld_TTSFactory_copy(inworld_TTSFactory* carg1);

SWIGIMPORT inworld_SilenceIntervals* inworld_SilenceIntervals_new();

SWIGIMPORT inworld_SilenceIntervals* inworld_SilenceIntervals_copy(inworld_SilenceIntervals* carg1);

SWIGIMPORT size_t inworld_SilenceIntervals_size(inworld_SilenceIntervals* carg1);

SWIGIMPORT size_t inworld_SilenceIntervals_capacity(inworld_SilenceIntervals* carg1);

SWIGIMPORT void inworld_SilenceIntervals_reserve(inworld_SilenceIntervals* carg1, size_t carg2);

SWIGIMPORT bool inworld_SilenceIntervals_empty(inworld_SilenceIntervals* carg1);

SWIGIMPORT void inworld_SilenceIntervals_clear(inworld_SilenceIntervals* carg1);

SWIGIMPORT void inworld_SilenceIntervals_push_back(inworld_SilenceIntervals* carg1, inworld_IntPair* carg2);

SWIGIMPORT inworld_IntPair* inworld_SilenceIntervals_get(inworld_SilenceIntervals* carg1, int carg2);

SWIGIMPORT void inworld_SilenceIntervals_set(inworld_SilenceIntervals* carg1, int carg2, inworld_IntPair* carg3);

SWIGIMPORT void inworld_SilenceIntervals_delete(inworld_SilenceIntervals* carg1);

SWIGIMPORT inworld_IntPair* inworld_IntPair_new();

SWIGIMPORT inworld_IntPair* inworld_IntPair_new_i_i(int carg1, int carg2);

SWIGIMPORT inworld_IntPair* inworld_IntPair_copy(inworld_IntPair* carg1);

SWIGIMPORT void inworld_IntPair_first_set(inworld_IntPair* carg1, int carg2);

SWIGIMPORT int inworld_IntPair_first_get(inworld_IntPair* carg1);

SWIGIMPORT void inworld_IntPair_second_set(inworld_IntPair* carg1, int carg2);

SWIGIMPORT int inworld_IntPair_second_get(inworld_IntPair* carg1);

SWIGIMPORT void inworld_IntPair_delete(inworld_IntPair* carg1);

SWIGIMPORT void inworld_VoiceActivityDetectionConfig_speech_threshold_set(inworld_VoiceActivityDetectionConfig* carg1, float carg2);

SWIGIMPORT float inworld_VoiceActivityDetectionConfig_speech_threshold_get(inworld_VoiceActivityDetectionConfig* carg1);

SWIGIMPORT inworld_VoiceActivityDetectionConfig* inworld_VoiceActivityDetectionConfig_new();

SWIGIMPORT inworld_VoiceActivityDetectionConfig* inworld_VoiceActivityDetectionConfig_copy(inworld_VoiceActivityDetectionConfig* carg1);

SWIGIMPORT void inworld_VoiceActivityDetectionConfig_delete(inworld_VoiceActivityDetectionConfig* carg1);

SWIGIMPORT void inworld_VADInterface_delete(inworld_VADInterface* carg1);

SWIGIMPORT bool inworld_VADInterface_is_valid(inworld_VADInterface* carg1);

SWIGIMPORT inworld_StatusOr_int* inworld_VADInterface_DetectVoiceActivity_rcinworld_AudioChunk_rcinworld_VoiceActivityDetectionConfig(inworld_VADInterface* carg1, inworld_AudioChunk* carg2, inworld_VoiceActivityDetectionConfig* carg3);

SWIGIMPORT inworld_StatusOr_int* inworld_VADInterface_DetectVoiceActivity_rcinworld_AudioChunk(inworld_VADInterface* carg1, inworld_AudioChunk* carg2);

SWIGIMPORT inworld_StatusOr_SilenceIntervals* inworld_VADInterface_DetectSilence_rcstd_vector_Sl_float_Sg__i_rcinworld_VoiceActivityDetectionConfig(inworld_VADInterface* carg1, inworld_vector_float* carg2, int carg3, inworld_VoiceActivityDetectionConfig* carg4);

SWIGIMPORT inworld_StatusOr_SilenceIntervals* inworld_VADInterface_DetectSilence_rcstd_vector_Sl_float_Sg__i(inworld_VADInterface* carg1, inworld_vector_float* carg2, int carg3);

SWIGIMPORT inworld_ModelProperties* inworld_VADInterface_model_properties(inworld_VADInterface* carg1);

SWIGIMPORT void inworld_LocalVADConfig_model_path_set(inworld_LocalVADConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LocalVADConfig_model_path_get(inworld_LocalVADConfig* carg1);

SWIGIMPORT void inworld_LocalVADConfig_device_set(inworld_LocalVADConfig* carg1, inworld_Device* carg2);

SWIGIMPORT inworld_Device* inworld_LocalVADConfig_device_get(inworld_LocalVADConfig* carg1);

SWIGIMPORT void inworld_LocalVADConfig_default_config_set(inworld_LocalVADConfig* carg1, inworld_VoiceActivityDetectionConfig* carg2);

SWIGIMPORT inworld_VoiceActivityDetectionConfig* inworld_LocalVADConfig_default_config_get(inworld_LocalVADConfig* carg1);

SWIGIMPORT inworld_LocalVADConfig* inworld_LocalVADConfig_new();

SWIGIMPORT inworld_LocalVADConfig* inworld_LocalVADConfig_copy(inworld_LocalVADConfig* carg1);

SWIGIMPORT void inworld_LocalVADConfig_delete(inworld_LocalVADConfig* carg1);

SWIGIMPORT void inworld_VADFactory_delete(inworld_VADFactory* carg1);

SWIGIMPORT inworld_StatusOr_VADInterface* inworld_VADFactory_CreateVAD(inworld_VADFactory* carg1, inworld_LocalVADConfig* carg2);

SWIGIMPORT inworld_VADFactory* inworld_VADFactory_new();

SWIGIMPORT inworld_VADFactory* inworld_VADFactory_copy(inworld_VADFactory* carg1);

SWIGIMPORT inworld_AcousticEchoCancellationConfig* inworld_AcousticEchoCancellationConfig_new();

SWIGIMPORT inworld_AcousticEchoCancellationConfig* inworld_AcousticEchoCancellationConfig_copy(inworld_AcousticEchoCancellationConfig* carg1);

SWIGIMPORT void inworld_AcousticEchoCancellationConfig_delete(inworld_AcousticEchoCancellationConfig* carg1);

SWIGIMPORT void inworld_AECFilterInterface_delete(inworld_AECFilterInterface* carg1);

SWIGIMPORT bool inworld_AECFilterInterface_is_valid(inworld_AECFilterInterface* carg1);

SWIGIMPORT inworld_StatusOr_AudioChunk* inworld_AECFilterInterface_FilterAudio(inworld_AECFilterInterface* carg1, inworld_AudioChunk* carg2, inworld_AudioChunk* carg3);

SWIGIMPORT inworld_ModelProperties* inworld_AECFilterInterface_model_properties(inworld_AECFilterInterface* carg1);

SWIGIMPORT void inworld_LocalAECFilterConfig_device_set(inworld_LocalAECFilterConfig* carg1, inworld_Device* carg2);

SWIGIMPORT inworld_Device* inworld_LocalAECFilterConfig_device_get(inworld_LocalAECFilterConfig* carg1);

SWIGIMPORT void inworld_LocalAECFilterConfig_default_config_set(inworld_LocalAECFilterConfig* carg1, inworld_AcousticEchoCancellationConfig* carg2);

SWIGIMPORT inworld_AcousticEchoCancellationConfig* inworld_LocalAECFilterConfig_default_config_get(inworld_LocalAECFilterConfig* carg1);

SWIGIMPORT inworld_LocalAECFilterConfig* inworld_LocalAECFilterConfig_new();

SWIGIMPORT inworld_LocalAECFilterConfig* inworld_LocalAECFilterConfig_copy(inworld_LocalAECFilterConfig* carg1);

SWIGIMPORT void inworld_LocalAECFilterConfig_delete(inworld_LocalAECFilterConfig* carg1);

SWIGIMPORT void inworld_AECFilterFactory_delete(inworld_AECFilterFactory* carg1);

SWIGIMPORT inworld_StatusOr_AECFilterInterface* inworld_AECFilterFactory_CreateAECFilter(inworld_AECFilterFactory* carg1, inworld_LocalAECFilterConfig* carg2);

SWIGIMPORT inworld_AECFilterFactory* inworld_AECFilterFactory_new();

SWIGIMPORT inworld_AECFilterFactory* inworld_AECFilterFactory_copy(inworld_AECFilterFactory* carg1);

SWIGIMPORT const char * inworld_NodeExecutionTelemetryContext_execution_id(inworld_NodeExecutionTelemetryContext* carg1);

SWIGIMPORT bool inworld_NodeExecutionTelemetryContext_is_valid(inworld_NodeExecutionTelemetryContext* carg1);

SWIGIMPORT void inworld_NodeExecutionTelemetryContext_delete(inworld_NodeExecutionTelemetryContext* carg1);

SWIGIMPORT void inworld_CancellationContext_delete(inworld_CancellationContext* carg1);

SWIGIMPORT bool inworld_CancellationContext_IsCancelled(inworld_CancellationContext* carg1);

SWIGIMPORT bool inworld_CancellationContext_is_valid(inworld_CancellationContext* carg1);

SWIGIMPORT void inworld_ProcessContext_delete(inworld_ProcessContext* carg1);

SWIGIMPORT inworld_ProcessContext* inworld_ProcessContext_copy(inworld_ProcessContext* carg1);

SWIGIMPORT const char * inworld_ProcessContext_GetVariant(inworld_ProcessContext* carg1);

SWIGIMPORT const char * inworld_ProcessContext_GetExecutionId(inworld_ProcessContext* carg1);

SWIGIMPORT inworld_NodeExecutionConfig* inworld_ProcessContext_GetConfig(inworld_ProcessContext* carg1);

SWIGIMPORT bool inworld_ProcessContext_IsCancelled(inworld_ProcessContext* carg1);

SWIGIMPORT inworld_CancellationContext* inworld_ProcessContext_GetCancellationContext(inworld_ProcessContext* carg1);

SWIGIMPORT inworld_NodeExecutionTelemetryContext* inworld_ProcessContext_GetNodeExecutionTelemetryContext(inworld_ProcessContext* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_GoalAdvancementNode* inworld_ProcessContext_GetComponent_GoalAdvancementNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_IntentNode* inworld_ProcessContext_GetComponent_IntentNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_KeywordMatcherNode* inworld_ProcessContext_GetComponent_KeywordMatcherNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeNode* inworld_ProcessContext_GetComponent_KnowledgeNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMChatNode* inworld_ProcessContext_GetComponent_LLMChatNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionNode* inworld_ProcessContext_GetComponent_LLMCompletionNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryUpdateNode* inworld_ProcessContext_GetComponent_MemoryUpdateNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryRetrieveNode* inworld_ProcessContext_GetComponent_MemoryRetrieveNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_RandomCannedTextNode* inworld_ProcessContext_GetComponent_RandomCannedTextNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyCheckerNode* inworld_ProcessContext_GetComponent_SafetyCheckerNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_STTNode* inworld_ProcessContext_GetComponent_STTNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextAggregatorNode* inworld_ProcessContext_GetComponent_TextAggregatorNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextChunkingNode* inworld_ProcessContext_GetComponent_TextChunkingNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_TTSNode* inworld_ProcessContext_GetComponent_TTSNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPListToolsNode* inworld_ProcessContext_GetComponent_MCPListToolsNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPCallToolNode* inworld_ProcessContext_GetComponent_MCPCallToolNode(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_LLMInterface* inworld_ProcessContext_GetComponent_LLMInterface(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_STTInterface* inworld_ProcessContext_GetComponent_STTInterface(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_StreamingSTTInterface* inworld_ProcessContext_GetComponent_StreamingSTTInterface(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_TTSInterface* inworld_ProcessContext_GetComponent_TTSInterface(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_TextEmbedderInterface* inworld_ProcessContext_GetComponent_TextEmbedderInterface(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_KnowledgeInterface* inworld_ProcessContext_GetComponent_KnowledgeInterface(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_MCPClientInterface* inworld_ProcessContext_GetComponent_MCPClientInterface(inworld_ProcessContext* carg1, const char * carg2);

SWIGIMPORT inworld_vector_BaseData* inworld_vector_BaseData_new();

SWIGIMPORT inworld_vector_BaseData* inworld_vector_BaseData_copy(inworld_vector_BaseData* carg1);

SWIGIMPORT size_t inworld_vector_BaseData_size(inworld_vector_BaseData* carg1);

SWIGIMPORT size_t inworld_vector_BaseData_capacity(inworld_vector_BaseData* carg1);

SWIGIMPORT void inworld_vector_BaseData_reserve(inworld_vector_BaseData* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_BaseData_empty(inworld_vector_BaseData* carg1);

SWIGIMPORT void inworld_vector_BaseData_clear(inworld_vector_BaseData* carg1);

SWIGIMPORT void inworld_vector_BaseData_push_back(inworld_vector_BaseData* carg1, inworld_BaseData* carg2);

SWIGIMPORT inworld_BaseData* inworld_vector_BaseData_get(inworld_vector_BaseData* carg1, int carg2);

SWIGIMPORT void inworld_vector_BaseData_set(inworld_vector_BaseData* carg1, int carg2, inworld_BaseData* carg3);

SWIGIMPORT inworld_BaseData* inworld_vector_BaseData_safe_get(inworld_vector_BaseData* carg1, size_t carg2);

SWIGIMPORT void inworld_vector_BaseData_delete(inworld_vector_BaseData* carg1);

SWIGIMPORT inworld_vector_Text* inworld_vector_Text_new();

SWIGIMPORT inworld_vector_Text* inworld_vector_Text_copy(inworld_vector_Text* carg1);

SWIGIMPORT size_t inworld_vector_Text_size(inworld_vector_Text* carg1);

SWIGIMPORT size_t inworld_vector_Text_capacity(inworld_vector_Text* carg1);

SWIGIMPORT void inworld_vector_Text_reserve(inworld_vector_Text* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_Text_empty(inworld_vector_Text* carg1);

SWIGIMPORT void inworld_vector_Text_clear(inworld_vector_Text* carg1);

SWIGIMPORT void inworld_vector_Text_push_back(inworld_vector_Text* carg1, inworld_Text* carg2);

SWIGIMPORT inworld_Text* inworld_vector_Text_get(inworld_vector_Text* carg1, int carg2);

SWIGIMPORT void inworld_vector_Text_set(inworld_vector_Text* carg1, int carg2, inworld_Text* carg3);

SWIGIMPORT void inworld_vector_Text_delete(inworld_vector_Text* carg1);

SWIGIMPORT inworld_vector_ToolCallResult* inworld_vector_ToolCallResult_new();

SWIGIMPORT inworld_vector_ToolCallResult* inworld_vector_ToolCallResult_copy(inworld_vector_ToolCallResult* carg1);

SWIGIMPORT size_t inworld_vector_ToolCallResult_size(inworld_vector_ToolCallResult* carg1);

SWIGIMPORT size_t inworld_vector_ToolCallResult_capacity(inworld_vector_ToolCallResult* carg1);

SWIGIMPORT void inworld_vector_ToolCallResult_reserve(inworld_vector_ToolCallResult* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_ToolCallResult_empty(inworld_vector_ToolCallResult* carg1);

SWIGIMPORT void inworld_vector_ToolCallResult_clear(inworld_vector_ToolCallResult* carg1);

SWIGIMPORT void inworld_vector_ToolCallResult_push_back(inworld_vector_ToolCallResult* carg1, inworld_ToolCallResult* carg2);

SWIGIMPORT inworld_ToolCallResult* inworld_vector_ToolCallResult_get(inworld_vector_ToolCallResult* carg1, int carg2);

SWIGIMPORT void inworld_vector_ToolCallResult_set(inworld_vector_ToolCallResult* carg1, int carg2, inworld_ToolCallResult* carg3);

SWIGIMPORT void inworld_vector_ToolCallResult_delete(inworld_vector_ToolCallResult* carg1);

SWIGIMPORT inworld_StatusOr_Json* inworld_StatusOr_Json_new();

SWIGIMPORT inworld_StatusOr_Json* inworld_StatusOr_Json_new_rcstd_shared_ptr_Sl_inworld_graphs_Json_Sg_(inworld_Json* carg1);

SWIGIMPORT inworld_StatusOr_Json* inworld_StatusOr_Json_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_Json_ok(inworld_StatusOr_Json* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_Json_status(inworld_StatusOr_Json* carg1);

SWIGIMPORT inworld_Json* inworld_StatusOr_Json_value(inworld_StatusOr_Json* carg1);

SWIGIMPORT inworld_StatusOr_Json* inworld_StatusOr_Json_copy(inworld_StatusOr_Json* carg1);

SWIGIMPORT void inworld_StatusOr_Json_delete(inworld_StatusOr_Json* carg1);

SWIGIMPORT inworld_StatusOr_LLMCompletionRequest* inworld_StatusOr_LLMCompletionRequest_new();

SWIGIMPORT inworld_StatusOr_LLMCompletionRequest* inworld_StatusOr_LLMCompletionRequest_new_rcstd_shared_ptr_Sl_inworld_graphs_LLMCompletionRequest_Sg_(inworld_LLMCompletionRequest* carg1);

SWIGIMPORT inworld_StatusOr_LLMCompletionRequest* inworld_StatusOr_LLMCompletionRequest_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_LLMCompletionRequest_ok(inworld_StatusOr_LLMCompletionRequest* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_LLMCompletionRequest_status(inworld_StatusOr_LLMCompletionRequest* carg1);

SWIGIMPORT inworld_LLMCompletionRequest* inworld_StatusOr_LLMCompletionRequest_value(inworld_StatusOr_LLMCompletionRequest* carg1);

SWIGIMPORT inworld_StatusOr_LLMCompletionRequest* inworld_StatusOr_LLMCompletionRequest_copy(inworld_StatusOr_LLMCompletionRequest* carg1);

SWIGIMPORT void inworld_StatusOr_LLMCompletionRequest_delete(inworld_StatusOr_LLMCompletionRequest* carg1);

SWIGIMPORT void inworld_BaseData_delete(inworld_BaseData* carg1);

SWIGIMPORT const char * inworld_BaseData_ToString(inworld_BaseData* carg1);

SWIGIMPORT bool inworld_BaseData_is_valid(inworld_BaseData* carg1);

SWIGIMPORT inworld_Text* inworld_Text_new();

SWIGIMPORT inworld_Text* inworld_Text_new_std_string(const char * carg1);

SWIGIMPORT const char * inworld_Text_value(inworld_Text* carg1);

SWIGIMPORT bool inworld_Text_is_valid(inworld_Text* carg1);

SWIGIMPORT inworld_Text* inworld_Text_new_rcstd_string_rcstd_string(const char * carg1, const char * carg2);

SWIGIMPORT inworld_Text* inworld_Text_copy(inworld_Text* carg1);

SWIGIMPORT void inworld_Text_delete(inworld_Text* carg1);

SWIGIMPORT const char * inworld_Text_ToString(inworld_Text* carg1);

SWIGIMPORT inworld_Audio* inworld_Audio_new();

SWIGIMPORT inworld_Audio* inworld_Audio_new_std_vector_Sl_float_Sg__i(inworld_vector_float* carg1, int carg2);

SWIGIMPORT inworld_vector_float* inworld_Audio_data(inworld_Audio* carg1);

SWIGIMPORT int inworld_Audio_sample_rate(inworld_Audio* carg1);

SWIGIMPORT bool inworld_Audio_is_valid(inworld_Audio* carg1);

SWIGIMPORT inworld_Audio* inworld_Audio_copy(inworld_Audio* carg1);

SWIGIMPORT void inworld_Audio_delete(inworld_Audio* carg1);

SWIGIMPORT const char * inworld_Audio_ToString(inworld_Audio* carg1);

SWIGIMPORT inworld_TTSOutput* inworld_TTSOutput_new_std_string_std_shared_ptr_Sl_inworld_graphs_Audio_Sg_(const char * carg1, inworld_Audio* carg2);

SWIGIMPORT void inworld_TTSOutput_text_set(inworld_TTSOutput* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TTSOutput_text_get(inworld_TTSOutput* carg1);

SWIGIMPORT void inworld_TTSOutput_audio_set(inworld_TTSOutput* carg1, inworld_Audio* carg2);

SWIGIMPORT inworld_Audio* inworld_TTSOutput_audio_get(inworld_TTSOutput* carg1);

SWIGIMPORT inworld_Audio* inworld_TTSOutput_safe_audio(inworld_TTSOutput* carg1);

SWIGIMPORT inworld_TTSOutput* inworld_TTSOutput_copy(inworld_TTSOutput* carg1);

SWIGIMPORT void inworld_TTSOutput_delete(inworld_TTSOutput* carg1);

SWIGIMPORT void inworld_PhraseMatch_phrase_set(inworld_PhraseMatch* carg1, const char * carg2);

SWIGIMPORT const char * inworld_PhraseMatch_phrase_get(inworld_PhraseMatch* carg1);

SWIGIMPORT void inworld_PhraseMatch_score_set(inworld_PhraseMatch* carg1, float carg2);

SWIGIMPORT float inworld_PhraseMatch_score_get(inworld_PhraseMatch* carg1);

SWIGIMPORT inworld_PhraseMatch* inworld_PhraseMatch_new();

SWIGIMPORT inworld_PhraseMatch* inworld_PhraseMatch_copy(inworld_PhraseMatch* carg1);

SWIGIMPORT void inworld_PhraseMatch_delete(inworld_PhraseMatch* carg1);

SWIGIMPORT inworld_SafetyResult* inworld_SafetyResult_new();

SWIGIMPORT inworld_SafetyResult* inworld_SafetyResult_new_std_string_b(const char * carg1, bool carg2);

SWIGIMPORT bool inworld_SafetyResult_is_safe(inworld_SafetyResult* carg1);

SWIGIMPORT const char * inworld_SafetyResult_text(inworld_SafetyResult* carg1);

SWIGIMPORT bool inworld_SafetyResult_is_valid(inworld_SafetyResult* carg1);

SWIGIMPORT inworld_SafetyResult* inworld_SafetyResult_copy(inworld_SafetyResult* carg1);

SWIGIMPORT void inworld_SafetyResult_delete(inworld_SafetyResult* carg1);

SWIGIMPORT const char * inworld_SafetyResult_ToString(inworld_SafetyResult* carg1);

SWIGIMPORT inworld_MatchedKeywords* inworld_MatchedKeywords_new();

SWIGIMPORT inworld_MatchedKeywords* inworld_MatchedKeywords_new_std_vector_Sl_inworld_KeywordMatch_Sg_(inworld_vector_KeywordMatch* carg1);

SWIGIMPORT inworld_vector_KeywordMatch* inworld_MatchedKeywords_matches(inworld_MatchedKeywords* carg1);

SWIGIMPORT bool inworld_MatchedKeywords_is_valid(inworld_MatchedKeywords* carg1);

SWIGIMPORT inworld_MatchedKeywords* inworld_MatchedKeywords_copy(inworld_MatchedKeywords* carg1);

SWIGIMPORT void inworld_MatchedKeywords_delete(inworld_MatchedKeywords* carg1);

SWIGIMPORT const char * inworld_MatchedKeywords_ToString(inworld_MatchedKeywords* carg1);

SWIGIMPORT inworld_MatchedPhrases* inworld_MatchedPhrases_new();

SWIGIMPORT inworld_MatchedPhrases* inworld_MatchedPhrases_new_std_vector_Sl_inworld_graphs_PhraseMatch_Sg_(inworld_vector_PhraseMatch* carg1);

SWIGIMPORT inworld_vector_PhraseMatch* inworld_MatchedPhrases_phrase_matches(inworld_MatchedPhrases* carg1);

SWIGIMPORT bool inworld_MatchedPhrases_is_valid(inworld_MatchedPhrases* carg1);

SWIGIMPORT inworld_MatchedPhrases* inworld_MatchedPhrases_copy(inworld_MatchedPhrases* carg1);

SWIGIMPORT void inworld_MatchedPhrases_delete(inworld_MatchedPhrases* carg1);

SWIGIMPORT const char * inworld_MatchedPhrases_ToString(inworld_MatchedPhrases* carg1);

SWIGIMPORT inworld_ClassificationResult* inworld_ClassificationResult_new();

SWIGIMPORT inworld_ClassificationResult* inworld_ClassificationResult_new_std_vector_Sl_std_string_Sg_(inworld_vector_string* carg1);

SWIGIMPORT inworld_vector_string* inworld_ClassificationResult_classes(inworld_ClassificationResult* carg1);

SWIGIMPORT bool inworld_ClassificationResult_HasClasses(inworld_ClassificationResult* carg1);

SWIGIMPORT bool inworld_ClassificationResult_is_valid(inworld_ClassificationResult* carg1);

SWIGIMPORT inworld_ClassificationResult* inworld_ClassificationResult_copy(inworld_ClassificationResult* carg1);

SWIGIMPORT void inworld_ClassificationResult_delete(inworld_ClassificationResult* carg1);

SWIGIMPORT const char * inworld_ClassificationResult_ToString(inworld_ClassificationResult* carg1);

SWIGIMPORT inworld_KnowledgeRecords* inworld_KnowledgeRecords_new();

SWIGIMPORT inworld_KnowledgeRecords* inworld_KnowledgeRecords_new_std_vector_Sl_std_string_Sg_(inworld_vector_string* carg1);

SWIGIMPORT inworld_vector_string* inworld_KnowledgeRecords_records(inworld_KnowledgeRecords* carg1);

SWIGIMPORT bool inworld_KnowledgeRecords_is_valid(inworld_KnowledgeRecords* carg1);

SWIGIMPORT inworld_KnowledgeRecords* inworld_KnowledgeRecords_copy(inworld_KnowledgeRecords* carg1);

SWIGIMPORT void inworld_KnowledgeRecords_delete(inworld_KnowledgeRecords* carg1);

SWIGIMPORT const char * inworld_KnowledgeRecords_ToString(inworld_KnowledgeRecords* carg1);

SWIGIMPORT inworld_Error* inworld_Error_new();

SWIGIMPORT inworld_Error* inworld_Error_new_absl_Status(inworld_Status* carg1);

SWIGIMPORT inworld_Status* inworld_Error_status(inworld_Error* carg1);

SWIGIMPORT bool inworld_Error_is_valid(inworld_Error* carg1);

SWIGIMPORT inworld_Error* inworld_Error_copy(inworld_Error* carg1);

SWIGIMPORT void inworld_Error_delete(inworld_Error* carg1);

SWIGIMPORT const char * inworld_Error_ToString(inworld_Error* carg1);

SWIGIMPORT inworld_MatchedIntents* inworld_MatchedIntents_new();

SWIGIMPORT inworld_MatchedIntents* inworld_MatchedIntents_new_std_vector_Sl_inworld_IntentMatch_Sg_(inworld_vector_IntentMatch* carg1);

SWIGIMPORT inworld_vector_IntentMatch* inworld_MatchedIntents_intent_matches(inworld_MatchedIntents* carg1);

SWIGIMPORT bool inworld_MatchedIntents_is_valid(inworld_MatchedIntents* carg1);

SWIGIMPORT inworld_MatchedIntents* inworld_MatchedIntents_copy(inworld_MatchedIntents* carg1);

SWIGIMPORT void inworld_MatchedIntents_delete(inworld_MatchedIntents* carg1);

SWIGIMPORT const char * inworld_MatchedIntents_ToString(inworld_MatchedIntents* carg1);

SWIGIMPORT inworld_GoalAdvancement* inworld_GoalAdvancement_new();

SWIGIMPORT inworld_vector_string* inworld_GoalAdvancement_activated_goals(inworld_GoalAdvancement* carg1);

SWIGIMPORT inworld_vector_string* inworld_GoalAdvancement_completed_goals(inworld_GoalAdvancement* carg1);

SWIGIMPORT inworld_vector_string* inworld_GoalAdvancement_current_goals(inworld_GoalAdvancement* carg1);

SWIGIMPORT bool inworld_GoalAdvancement_is_valid(inworld_GoalAdvancement* carg1);

SWIGIMPORT inworld_GoalAdvancement* inworld_GoalAdvancement_copy(inworld_GoalAdvancement* carg1);

SWIGIMPORT void inworld_GoalAdvancement_delete(inworld_GoalAdvancement* carg1);

SWIGIMPORT const char * inworld_GoalAdvancement_ToString(inworld_GoalAdvancement* carg1);

SWIGIMPORT inworld_Json* inworld_Json_new();

SWIGIMPORT bool inworld_Json_is_valid(inworld_Json* carg1);

SWIGIMPORT inworld_StatusOr_Json* inworld_Json_FromString(const char * carg1);

SWIGIMPORT const char * inworld_Json_value_as_string(inworld_Json* carg1);

SWIGIMPORT inworld_Json* inworld_Json_copy(inworld_Json* carg1);

SWIGIMPORT void inworld_Json_delete(inworld_Json* carg1);

SWIGIMPORT const char * inworld_Json_ToString(inworld_Json* carg1);

SWIGIMPORT inworld_ToolCallRequest* inworld_ToolCallRequest_new();

SWIGIMPORT inworld_ToolCallRequest* inworld_ToolCallRequest_new_std_vector_Sl_inworld_ToolCall_Sg_(inworld_ToolCalls* carg1);

SWIGIMPORT inworld_ToolCalls* inworld_ToolCallRequest_tool_calls(inworld_ToolCallRequest* carg1);

SWIGIMPORT bool inworld_ToolCallRequest_is_valid(inworld_ToolCallRequest* carg1);

SWIGIMPORT inworld_ToolCallRequest* inworld_ToolCallRequest_copy(inworld_ToolCallRequest* carg1);

SWIGIMPORT void inworld_ToolCallRequest_delete(inworld_ToolCallRequest* carg1);

SWIGIMPORT const char * inworld_ToolCallRequest_ToString(inworld_ToolCallRequest* carg1);

SWIGIMPORT inworld_ListToolsResponse* inworld_ListToolsResponse_new();

SWIGIMPORT inworld_ListToolsResponse* inworld_ListToolsResponse_new_std_vector_Sl_inworld_Tool_Sg_(inworld_Vector_Tool* carg1);

SWIGIMPORT inworld_Vector_Tool* inworld_ListToolsResponse_list_tools(inworld_ListToolsResponse* carg1);

SWIGIMPORT bool inworld_ListToolsResponse_is_valid(inworld_ListToolsResponse* carg1);

SWIGIMPORT inworld_ListToolsResponse* inworld_ListToolsResponse_copy(inworld_ListToolsResponse* carg1);

SWIGIMPORT void inworld_ListToolsResponse_delete(inworld_ListToolsResponse* carg1);

SWIGIMPORT const char * inworld_ListToolsResponse_ToString(inworld_ListToolsResponse* carg1);

SWIGIMPORT inworld_LLMChatRequest* inworld_LLMChatRequest_new();

SWIGIMPORT inworld_LLMChatRequest* inworld_LLMChatRequest_new_std_vector_Sl_inworld_Message_Sg__std_vector_Sl_inworld_Tool_Sg__std_optional_Sl_inworld_ToolChoice_Sg__eResponseFormat_std_optional_Sl_inworld_TextGenerationConfig_Sg_(inworld_Messages* carg1, inworld_Vector_Tool* carg2, inworld_optional_ToolChoice* carg3, enum inworld_ResponseFormat carg4, inworld_optional_TextGenerationConfig* carg5);

SWIGIMPORT inworld_LLMChatRequest* inworld_LLMChatRequest_new_std_vector_Sl_inworld_Message_Sg__std_vector_Sl_inworld_Tool_Sg__std_optional_Sl_inworld_ToolChoice_Sg__eResponseFormat(inworld_Messages* carg1, inworld_Vector_Tool* carg2, inworld_optional_ToolChoice* carg3, enum inworld_ResponseFormat carg4);

SWIGIMPORT inworld_LLMChatRequest* inworld_LLMChatRequest_new_std_vector_Sl_inworld_Message_Sg__std_vector_Sl_inworld_Tool_Sg__std_optional_Sl_inworld_ToolChoice_Sg_(inworld_Messages* carg1, inworld_Vector_Tool* carg2, inworld_optional_ToolChoice* carg3);

SWIGIMPORT inworld_LLMChatRequest* inworld_LLMChatRequest_new_std_vector_Sl_inworld_Message_Sg__std_vector_Sl_inworld_Tool_Sg_(inworld_Messages* carg1, inworld_Vector_Tool* carg2);

SWIGIMPORT inworld_LLMChatRequest* inworld_LLMChatRequest_new_std_vector_Sl_inworld_Message_Sg_(inworld_Messages* carg1);

SWIGIMPORT inworld_Messages* inworld_LLMChatRequest_messages(inworld_LLMChatRequest* carg1);

SWIGIMPORT inworld_Vector_Tool* inworld_LLMChatRequest_tools(inworld_LLMChatRequest* carg1);

SWIGIMPORT inworld_optional_ToolChoice* inworld_LLMChatRequest_tool_choice(inworld_LLMChatRequest* carg1);

SWIGIMPORT enum inworld_ResponseFormat inworld_LLMChatRequest_response_format(inworld_LLMChatRequest* carg1);

SWIGIMPORT inworld_optional_TextGenerationConfig* inworld_LLMChatRequest_text_generation_config(inworld_LLMChatRequest* carg1);

SWIGIMPORT bool inworld_LLMChatRequest_is_valid(inworld_LLMChatRequest* carg1);

SWIGIMPORT inworld_LLMChatRequest* inworld_LLMChatRequest_copy(inworld_LLMChatRequest* carg1);

SWIGIMPORT void inworld_LLMChatRequest_delete(inworld_LLMChatRequest* carg1);

SWIGIMPORT const char * inworld_LLMChatRequest_ToString(inworld_LLMChatRequest* carg1);

SWIGIMPORT inworld_LLMChatResponse* inworld_LLMChatResponse_new();

SWIGIMPORT inworld_LLMChatResponse* inworld_LLMChatResponse_new_inworld_Content(inworld_Content* carg1);

SWIGIMPORT bool inworld_LLMChatResponse_is_streaming(inworld_LLMChatResponse* carg1);

SWIGIMPORT bool inworld_LLMChatResponse_is_valid(inworld_LLMChatResponse* carg1);

SWIGIMPORT bool inworld_LLMChatResponse_has_complete_content(inworld_LLMChatResponse* carg1);

SWIGIMPORT inworld_Content* inworld_LLMChatResponse_get_response_content(inworld_LLMChatResponse* carg1);

SWIGIMPORT inworld_InputStream_Content* inworld_LLMChatResponse_get_response_stream(inworld_LLMChatResponse* carg1);

SWIGIMPORT inworld_LLMChatResponse* inworld_LLMChatResponse_copy(inworld_LLMChatResponse* carg1);

SWIGIMPORT void inworld_LLMChatResponse_delete(inworld_LLMChatResponse* carg1);

SWIGIMPORT const char * inworld_LLMChatResponse_ToString(inworld_LLMChatResponse* carg1);

SWIGIMPORT inworld_LLMCompletionRequest* inworld_LLMCompletionRequest_new();

SWIGIMPORT inworld_LLMCompletionRequest* inworld_LLMCompletionRequest_new_std_string_std_optional_Sl_inworld_TextGenerationConfig_Sg_(const char * carg1, inworld_optional_TextGenerationConfig* carg2);

SWIGIMPORT inworld_LLMCompletionRequest* inworld_LLMCompletionRequest_new_std_string(const char * carg1);

SWIGIMPORT const char * inworld_LLMCompletionRequest_text(inworld_LLMCompletionRequest* carg1);

SWIGIMPORT inworld_optional_TextGenerationConfig* inworld_LLMCompletionRequest_text_generation_config(inworld_LLMCompletionRequest* carg1);

SWIGIMPORT bool inworld_LLMCompletionRequest_is_valid(inworld_LLMCompletionRequest* carg1);

SWIGIMPORT inworld_LLMCompletionRequest* inworld_LLMCompletionRequest_copy(inworld_LLMCompletionRequest* carg1);

SWIGIMPORT void inworld_LLMCompletionRequest_delete(inworld_LLMCompletionRequest* carg1);

SWIGIMPORT const char * inworld_LLMCompletionRequest_ToString(inworld_LLMCompletionRequest* carg1);

SWIGIMPORT inworld_LLMCompletionResponse* inworld_LLMCompletionResponse_new();

SWIGIMPORT inworld_LLMCompletionResponse* inworld_LLMCompletionResponse_new_std_string(const char * carg1);

SWIGIMPORT bool inworld_LLMCompletionResponse_is_streaming(inworld_LLMCompletionResponse* carg1);

SWIGIMPORT bool inworld_LLMCompletionResponse_is_valid(inworld_LLMCompletionResponse* carg1);

SWIGIMPORT bool inworld_LLMCompletionResponse_has_complete_content(inworld_LLMCompletionResponse* carg1);

SWIGIMPORT const char * inworld_LLMCompletionResponse_get_content_text(inworld_LLMCompletionResponse* carg1);

SWIGIMPORT inworld_InputStream_string* inworld_LLMCompletionResponse_get_input_stream(inworld_LLMCompletionResponse* carg1);

SWIGIMPORT inworld_LLMCompletionResponse* inworld_LLMCompletionResponse_copy(inworld_LLMCompletionResponse* carg1);

SWIGIMPORT void inworld_LLMCompletionResponse_delete(inworld_LLMCompletionResponse* carg1);

SWIGIMPORT const char * inworld_LLMCompletionResponse_ToString(inworld_LLMCompletionResponse* carg1);

SWIGIMPORT inworld_ToolCallResult* inworld_ToolCallResult_new();

SWIGIMPORT inworld_ToolCallResult* inworld_ToolCallResult_new_std_string_std_string(const char * carg1, const char * carg2);

SWIGIMPORT const char * inworld_ToolCallResult_tool_call_id(inworld_ToolCallResult* carg1);

SWIGIMPORT const char * inworld_ToolCallResult_result(inworld_ToolCallResult* carg1);

SWIGIMPORT bool inworld_ToolCallResult_is_valid(inworld_ToolCallResult* carg1);

SWIGIMPORT inworld_ToolCallResult* inworld_ToolCallResult_copy(inworld_ToolCallResult* carg1);

SWIGIMPORT void inworld_ToolCallResult_delete(inworld_ToolCallResult* carg1);

SWIGIMPORT const char * inworld_ToolCallResult_ToString(inworld_ToolCallResult* carg1);

SWIGIMPORT inworld_ToolCallResponse* inworld_ToolCallResponse_new();

SWIGIMPORT bool inworld_ToolCallResponse_is_valid(inworld_ToolCallResponse* carg1);

SWIGIMPORT inworld_ToolCallResponse* inworld_ToolCallResponse_new_std_vector_Sl_std_shared_ptr_Sl_inworld_graphs_ToolCallResult_Sg__Sg_(inworld_vector_ToolCallResult* carg1);

SWIGIMPORT inworld_vector_ToolCallResult* inworld_ToolCallResponse_tool_call_results_swig(inworld_ToolCallResponse* carg1);

SWIGIMPORT inworld_ToolCallResponse* inworld_ToolCallResponse_copy(inworld_ToolCallResponse* carg1);

SWIGIMPORT void inworld_ToolCallResponse_delete(inworld_ToolCallResponse* carg1);

SWIGIMPORT const char * inworld_ToolCallResponse_ToString(inworld_ToolCallResponse* carg1);

SWIGIMPORT inworld_TTSRequest* inworld_TTSRequest_new();

SWIGIMPORT inworld_optional_Voice* inworld_TTSRequest_voice(inworld_TTSRequest* carg1);

SWIGIMPORT inworld_optional_SpeechSynthesisConfig* inworld_TTSRequest_synthesis_config(inworld_TTSRequest* carg1);

SWIGIMPORT bool inworld_TTSRequest_is_valid(inworld_TTSRequest* carg1);

SWIGIMPORT inworld_TTSRequest* inworld_TTSRequest_new_std_shared_ptr_Sl_inworld_graphs_Text_Sg__std_optional_Sl_inworld_Voice_Sg__std_optional_Sl_inworld_SpeechSynthesisConfig_Sg_(inworld_Text* carg1, inworld_optional_Voice* carg2, inworld_optional_SpeechSynthesisConfig* carg3);

SWIGIMPORT inworld_TTSRequest* inworld_TTSRequest_new_std_shared_ptr_Sl_inworld_graphs_Text_Sg__std_optional_Sl_inworld_Voice_Sg_(inworld_Text* carg1, inworld_optional_Voice* carg2);

SWIGIMPORT inworld_TTSRequest* inworld_TTSRequest_new_rcstd_string_std_optional_Sl_inworld_Voice_Sg__std_optional_Sl_inworld_SpeechSynthesisConfig_Sg_(const char * carg1, inworld_optional_Voice* carg2, inworld_optional_SpeechSynthesisConfig* carg3);

SWIGIMPORT inworld_TTSRequest* inworld_TTSRequest_new_rcstd_string_std_optional_Sl_inworld_Voice_Sg_(const char * carg1, inworld_optional_Voice* carg2);

SWIGIMPORT inworld_TTSRequest* inworld_TTSRequest_new_std_shared_ptr_Sl_inworld_graphs_DataStream_Sl_std_string_Sg__Sg__std_optional_Sl_inworld_Voice_Sg__std_optional_Sl_inworld_SpeechSynthesisConfig_Sg_(inworld_DataStream_String* carg1, inworld_optional_Voice* carg2, inworld_optional_SpeechSynthesisConfig* carg3);

SWIGIMPORT inworld_TTSRequest* inworld_TTSRequest_new_std_shared_ptr_Sl_inworld_graphs_DataStream_Sl_std_string_Sg__Sg__std_optional_Sl_inworld_Voice_Sg_(inworld_DataStream_String* carg1, inworld_optional_Voice* carg2);

SWIGIMPORT bool inworld_TTSRequest_has_text_content(inworld_TTSRequest* carg1);

SWIGIMPORT bool inworld_TTSRequest_has_stream_content(inworld_TTSRequest* carg1);

SWIGIMPORT inworld_Text* inworld_TTSRequest_get_text_content(inworld_TTSRequest* carg1);

SWIGIMPORT inworld_InputStream_string* inworld_TTSRequest_get_content_stream(inworld_TTSRequest* carg1);

SWIGIMPORT inworld_optional_Voice* inworld_TTSRequest_get_voice(inworld_TTSRequest* carg1);

SWIGIMPORT inworld_optional_SpeechSynthesisConfig* inworld_TTSRequest_get_synthesis_config(inworld_TTSRequest* carg1);

SWIGIMPORT inworld_TTSRequest* inworld_TTSRequest_copy(inworld_TTSRequest* carg1);

SWIGIMPORT void inworld_TTSRequest_delete(inworld_TTSRequest* carg1);

SWIGIMPORT const char * inworld_TTSRequest_ToString(inworld_TTSRequest* carg1);

SWIGIMPORT inworld_STTRequest* inworld_STTRequest_new();

SWIGIMPORT inworld_optional_SpeechRecognitionConfig* inworld_STTRequest_speech_recognition_config(inworld_STTRequest* carg1);

SWIGIMPORT bool inworld_STTRequest_is_valid(inworld_STTRequest* carg1);

SWIGIMPORT inworld_STTRequest* inworld_STTRequest_new_std_shared_ptr_Sl_inworld_graphs_Audio_Sg__std_optional_Sl_inworld_SpeechRecognitionConfig_Sg_(inworld_Audio* carg1, inworld_optional_SpeechRecognitionConfig* carg2);

SWIGIMPORT inworld_STTRequest* inworld_STTRequest_new_std_shared_ptr_Sl_inworld_graphs_Audio_Sg_(inworld_Audio* carg1);

SWIGIMPORT inworld_STTRequest* inworld_STTRequest_new_std_shared_ptr_Sl_inworld_graphs_DataStream_Sl_inworld_AudioChunk_Sg__Sg__std_optional_Sl_inworld_SpeechRecognitionConfig_Sg_(inworld_DataStream_AudioChunk* carg1, inworld_optional_SpeechRecognitionConfig* carg2);

SWIGIMPORT inworld_STTRequest* inworld_STTRequest_new_std_shared_ptr_Sl_inworld_graphs_DataStream_Sl_inworld_AudioChunk_Sg__Sg_(inworld_DataStream_AudioChunk* carg1);

SWIGIMPORT bool inworld_STTRequest_has_audio_content(inworld_STTRequest* carg1);

SWIGIMPORT bool inworld_STTRequest_has_stream_content(inworld_STTRequest* carg1);

SWIGIMPORT inworld_Audio* inworld_STTRequest_get_audio_content(inworld_STTRequest* carg1);

SWIGIMPORT inworld_InputStream_AudioChunk* inworld_STTRequest_get_content_stream(inworld_STTRequest* carg1);

SWIGIMPORT inworld_optional_SpeechRecognitionConfig* inworld_STTRequest_get_speech_recognition_config(inworld_STTRequest* carg1);

SWIGIMPORT inworld_STTRequest* inworld_STTRequest_copy(inworld_STTRequest* carg1);

SWIGIMPORT void inworld_STTRequest_delete(inworld_STTRequest* carg1);

SWIGIMPORT const char * inworld_STTRequest_ToString(inworld_STTRequest* carg1);

SWIGIMPORT inworld_CustomDataToJsonExecutor* inworld_CustomDataToJsonExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_CustomDataToJsonExecutor_SetNextOutput(const char * carg1);

SWIGIMPORT inworld_CustomDataToJsonExecutor* inworld_CustomDataToJsonExecutor_copy(inworld_CustomDataToJsonExecutor* carg1);

SWIGIMPORT void inworld_CustomDataToJsonExecutor_delete(inworld_CustomDataToJsonExecutor* carg1);

SWIGIMPORT inworld_CustomDataDestructor* inworld_CustomDataDestructor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT inworld_CustomDataDestructor* inworld_CustomDataDestructor_copy(inworld_CustomDataDestructor* carg1);

SWIGIMPORT void inworld_CustomDataDestructor_delete(inworld_CustomDataDestructor* carg1);

SWIGIMPORT inworld_CustomDataWrapper* inworld_CustomDataWrapper_new_pcc_pv_rcinworld_swig_helpers_CustomDataToJsonExecutor_rcinworld_swig_helpers_CustomDataDestructor(const char * carg1, void * carg2, inworld_CustomDataToJsonExecutor* carg3, inworld_CustomDataDestructor* carg4);

SWIGIMPORT void inworld_CustomDataWrapper_delete(inworld_CustomDataWrapper* carg1);

SWIGIMPORT const char * inworld_CustomDataWrapper_type_id(inworld_CustomDataWrapper* carg1);

SWIGIMPORT void * inworld_CustomDataWrapper_value(inworld_CustomDataWrapper* carg1);

SWIGIMPORT bool inworld_CustomDataWrapper_is_valid(inworld_CustomDataWrapper* carg1);

SWIGIMPORT inworld_CustomDataWrapper* inworld_CustomDataWrapper_copy(inworld_CustomDataWrapper* carg1);

SWIGIMPORT const char * inworld_CustomDataWrapper_ToString(inworld_CustomDataWrapper* carg1);

SWIGIMPORT inworld_Error* inworld_BaseDataAs_Error(inworld_BaseData* carg1);

SWIGIMPORT inworld_Text* inworld_BaseDataAs_Text(inworld_BaseData* carg1);

SWIGIMPORT inworld_Audio* inworld_BaseDataAs_Audio(inworld_BaseData* carg1);

SWIGIMPORT inworld_MatchedIntents* inworld_BaseDataAs_MatchedIntents(inworld_BaseData* carg1);

SWIGIMPORT inworld_MatchedKeywords* inworld_BaseDataAs_MatchedKeywords(inworld_BaseData* carg1);

SWIGIMPORT inworld_MatchedPhrases* inworld_BaseDataAs_MatchedPhrases(inworld_BaseData* carg1);

SWIGIMPORT inworld_ClassificationResult* inworld_BaseDataAs_ClassificationResult(inworld_BaseData* carg1);

SWIGIMPORT inworld_GoalAdvancement* inworld_BaseDataAs_GoalAdvancement(inworld_BaseData* carg1);

SWIGIMPORT inworld_KnowledgeRecords* inworld_BaseDataAs_KnowledgeRecords(inworld_BaseData* carg1);

SWIGIMPORT inworld_Json* inworld_BaseDataAs_Json(inworld_BaseData* carg1);

SWIGIMPORT inworld_MemoryState* inworld_BaseDataAs_MemoryState(inworld_BaseData* carg1);

SWIGIMPORT inworld_LLMChatRequest* inworld_BaseDataAs_LLMChatRequest(inworld_BaseData* carg1);

SWIGIMPORT inworld_LLMChatResponse* inworld_BaseDataAs_LLMChatResponse(inworld_BaseData* carg1);

SWIGIMPORT inworld_LLMCompletionResponse* inworld_BaseDataAs_LLMCompletionResponse(inworld_BaseData* carg1);

SWIGIMPORT inworld_SafetyResult* inworld_BaseDataAs_SafetyResult(inworld_BaseData* carg1);

SWIGIMPORT inworld_TTSRequest* inworld_BaseDataAs_TTSRequest(inworld_BaseData* carg1);

SWIGIMPORT inworld_STTRequest* inworld_BaseDataAs_STTRequest(inworld_BaseData* carg1);

SWIGIMPORT inworld_CustomDataWrapper* inworld_BaseDataAs_CustomDataWrapper(inworld_BaseData* carg1);

SWIGIMPORT inworld_ListToolsResponse* inworld_BaseDataAs_ListToolsResponse(inworld_BaseData* carg1);

SWIGIMPORT inworld_ToolCallRequest* inworld_BaseDataAs_ToolCallRequest(inworld_BaseData* carg1);

SWIGIMPORT inworld_ToolCallResult* inworld_BaseDataAs_ToolCallResult(inworld_BaseData* carg1);

SWIGIMPORT inworld_ToolCallResponse* inworld_BaseDataAs_ToolCallResponse(inworld_BaseData* carg1);

SWIGIMPORT const char * inworld_type_id(inworld_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_StatusOr_BaseData_new();

SWIGIMPORT inworld_StatusOr_BaseData* inworld_StatusOr_BaseData_new_rcstd_shared_ptr_Sl_inworld_graphs_BaseData_Sg_(inworld_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_StatusOr_BaseData_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_BaseData_ok(inworld_StatusOr_BaseData* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_BaseData_status(inworld_StatusOr_BaseData* carg1);

SWIGIMPORT inworld_BaseData* inworld_StatusOr_BaseData_value(inworld_StatusOr_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_StatusOr_BaseData_copy(inworld_StatusOr_BaseData* carg1);

SWIGIMPORT void inworld_StatusOr_BaseData_delete(inworld_StatusOr_BaseData* carg1);

SWIGIMPORT void inworld_Node_delete(inworld_Node* carg1);

SWIGIMPORT const char * inworld_Node_id(inworld_Node* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_Node_Process(inworld_Node* carg1, inworld_ProcessContext* carg2, inworld_vector_BaseData* carg3);

SWIGIMPORT bool inworld_Node_is_valid(inworld_Node* carg1);

SWIGIMPORT void inworld_TypedNodeBase_delete(inworld_TypedNodeBase* carg1);

SWIGIMPORT bool inworld_TypedNodeBase_is_valid(inworld_TypedNodeBase* carg1);

SWIGIMPORT const char * inworld_TypedNodeBase_id(inworld_TypedNodeBase* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_TypedNodeBase_Process(inworld_TypedNodeBase* carg1, inworld_ProcessContext* carg2, inworld_vector_BaseData* carg3);

SWIGIMPORT inworld_CustomNodeProcessExecutor* inworld_CustomNodeProcessExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT inworld_vector_BaseData* inworld_CustomNodeProcessExecutor_GetLastInputs();

SWIGIMPORT inworld_ProcessContext* inworld_CustomNodeProcessExecutor_GetLastContext();

SWIGIMPORT void inworld_CustomNodeProcessExecutor_SetLastOutput(inworld_StatusOr_BaseData* carg1);

SWIGIMPORT inworld_CustomNodeProcessExecutor* inworld_CustomNodeProcessExecutor_copy(inworld_CustomNodeProcessExecutor* carg1);

SWIGIMPORT void inworld_CustomNodeProcessExecutor_delete(inworld_CustomNodeProcessExecutor* carg1);

SWIGIMPORT inworld_CustomNodeThreadedProcessExecutor* inworld_CustomNodeThreadedProcessExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT inworld_vector_BaseData* inworld_CustomNodeThreadedProcessExecutor_GetInputs(int carg1);

SWIGIMPORT inworld_ProcessContext* inworld_CustomNodeThreadedProcessExecutor_GetContext(int carg1);

SWIGIMPORT void inworld_CustomNodeThreadedProcessExecutor_SetOutput(int carg1, inworld_StatusOr_BaseData* carg2);

SWIGIMPORT inworld_CustomNodeThreadedProcessExecutor* inworld_CustomNodeThreadedProcessExecutor_copy(inworld_CustomNodeThreadedProcessExecutor* carg1);

SWIGIMPORT void inworld_CustomNodeThreadedProcessExecutor_delete(inworld_CustomNodeThreadedProcessExecutor* carg1);

SWIGIMPORT inworld_CustomNodeDestructor* inworld_CustomNodeDestructor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_CustomNodeDestructor_delete(inworld_CustomNodeDestructor* carg1);

SWIGIMPORT inworld_CustomNodeDestructor* inworld_CustomNodeDestructor_copy(inworld_CustomNodeDestructor* carg1);

SWIGIMPORT inworld_CustomNodeWrapper* inworld_CustomNodeWrapper_new_rcstd_string_rcinworld_swig_helpers_CustomNodeProcessExecutor(const char * carg1, inworld_CustomNodeProcessExecutor* carg2);

SWIGIMPORT inworld_CustomNodeWrapper* inworld_CustomNodeWrapper_new_rcstd_string_rcinworld_swig_helpers_CustomNodeThreadedProcessExecutor(const char * carg1, inworld_CustomNodeThreadedProcessExecutor* carg2);

SWIGIMPORT inworld_CustomNodeWrapper* inworld_CustomNodeWrapper_new_rcstd_string_rcinworld_swig_helpers_CustomNodeProcessExecutor_rcinworld_swig_helpers_CustomNodeDestructor(const char * carg1, inworld_CustomNodeProcessExecutor* carg2, inworld_CustomNodeDestructor* carg3);

SWIGIMPORT inworld_CustomNodeWrapper* inworld_CustomNodeWrapper_new_rcstd_string_rcinworld_swig_helpers_CustomNodeThreadedProcessExecutor_rcinworld_swig_helpers_CustomNodeDestructor(const char * carg1, inworld_CustomNodeThreadedProcessExecutor* carg2, inworld_CustomNodeDestructor* carg3);

SWIGIMPORT inworld_CustomNodeWrapper* inworld_CustomNodeWrapper_new_rcstd_string_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg__rcinworld_swig_helpers_CustomNodeProcessExecutor(const char * carg1, inworld_NodeExecutionConfig* carg2, inworld_CustomNodeProcessExecutor* carg3);

SWIGIMPORT inworld_CustomNodeWrapper* inworld_CustomNodeWrapper_new_rcstd_string_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg__rcinworld_swig_helpers_CustomNodeThreadedProcessExecutor(const char * carg1, inworld_NodeExecutionConfig* carg2, inworld_CustomNodeThreadedProcessExecutor* carg3);

SWIGIMPORT inworld_CustomNodeWrapper* inworld_CustomNodeWrapper_new_rcstd_string_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg__rcinworld_swig_helpers_CustomNodeProcessExecutor_rcinworld_swig_helpers_CustomNodeDestructor(const char * carg1, inworld_NodeExecutionConfig* carg2, inworld_CustomNodeProcessExecutor* carg3, inworld_CustomNodeDestructor* carg4);

SWIGIMPORT inworld_CustomNodeWrapper* inworld_CustomNodeWrapper_new_rcstd_string_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg__rcinworld_swig_helpers_CustomNodeThreadedProcessExecutor_rcinworld_swig_helpers_CustomNodeDestructor(const char * carg1, inworld_NodeExecutionConfig* carg2, inworld_CustomNodeThreadedProcessExecutor* carg3, inworld_CustomNodeDestructor* carg4);

SWIGIMPORT void inworld_CustomNodeWrapper_delete(inworld_CustomNodeWrapper* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_CustomNodeWrapper_Process(inworld_CustomNodeWrapper* carg1, inworld_ProcessContext* carg2, inworld_vector_BaseData* carg3);

SWIGIMPORT bool inworld_CustomNodeWrapper_is_valid(inworld_CustomNodeWrapper* carg1);

SWIGIMPORT inworld_CustomNodeWrapper* inworld_CustomNodeWrapper_copy(inworld_CustomNodeWrapper* carg1);

SWIGIMPORT const char * inworld_CustomNodeWrapper_id(inworld_CustomNodeWrapper* carg1);

SWIGIMPORT void inworld_TypedNode_Text_Text_delete(inworld_TypedNode_Text_Text* carg1);

SWIGIMPORT const char * inworld_TypedNode_Text_Text_id(inworld_TypedNode_Text_Text* carg1);

SWIGIMPORT void inworld_TypedNode_Text_Audio_delete(inworld_TypedNode_Text_Audio* carg1);

SWIGIMPORT const char * inworld_TypedNode_Text_Audio_id(inworld_TypedNode_Text_Audio* carg1);

SWIGIMPORT void inworld_TypedNode_BaseData_Text_delete(inworld_TypedNode_BaseData_Text* carg1);

SWIGIMPORT const char * inworld_TypedNode_BaseData_Text_id(inworld_TypedNode_BaseData_Text* carg1);

SWIGIMPORT void inworld_TypedNode_TTSOutputStream_Text_DataStream_String_delete(inworld_TypedNode_TTSOutputStream_Text_DataStream_String* carg1);

SWIGIMPORT const char * inworld_TypedNode_TTSOutputStream_Text_DataStream_String_id(inworld_TypedNode_TTSOutputStream_Text_DataStream_String* carg1);

SWIGIMPORT void inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest_delete(inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest* carg1);

SWIGIMPORT const char * inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest_id(inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest* carg1);

SWIGIMPORT void inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text_delete(inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text* carg1);

SWIGIMPORT const char * inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text_id(inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text* carg1);

SWIGIMPORT void inworld_TypedNode_KnowledgeRecords_Text_delete(inworld_TypedNode_KnowledgeRecords_Text* carg1);

SWIGIMPORT const char * inworld_TypedNode_KnowledgeRecords_Text_id(inworld_TypedNode_KnowledgeRecords_Text* carg1);

SWIGIMPORT void inworld_TypedNode_Text_Variant_Text_DataStream_String_delete(inworld_TypedNode_Text_Variant_Text_DataStream_String* carg1);

SWIGIMPORT const char * inworld_TypedNode_Text_Variant_Text_DataStream_String_id(inworld_TypedNode_Text_Variant_Text_DataStream_String* carg1);

SWIGIMPORT void inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_delete(inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String* carg1);

SWIGIMPORT const char * inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_id(inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String* carg1);

SWIGIMPORT void inworld_TypedNode_BaseData_LLMChatRequest_delete(inworld_TypedNode_BaseData_LLMChatRequest* carg1);

SWIGIMPORT const char * inworld_TypedNode_BaseData_LLMChatRequest_id(inworld_TypedNode_BaseData_LLMChatRequest* carg1);

SWIGIMPORT void inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_delete(inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk* carg1);

SWIGIMPORT const char * inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_id(inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk* carg1);

SWIGIMPORT void inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse_delete(inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse* carg1);

SWIGIMPORT const char * inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse_id(inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse* carg1);

SWIGIMPORT void inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse_delete(inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse* carg1);

SWIGIMPORT const char * inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse_id(inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse* carg1);

SWIGIMPORT void inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest_delete(inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest* carg1);

SWIGIMPORT const char * inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest_id(inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest* carg1);

SWIGIMPORT inworld_HashSet_String* inworld_HashSet_String_new();

SWIGIMPORT void inworld_HashSet_String_delete(inworld_HashSet_String* carg1);

SWIGIMPORT size_t inworld_HashSet_String_size(inworld_HashSet_String* carg1);

SWIGIMPORT bool inworld_HashSet_String_empty(inworld_HashSet_String* carg1);

SWIGIMPORT void inworld_HashSet_String_clear(inworld_HashSet_String* carg1);

SWIGIMPORT bool inworld_HashSet_String___contains__(inworld_HashSet_String* carg1, const char * carg2);

SWIGIMPORT void inworld_HashSet_String_add(inworld_HashSet_String* carg1, const char * carg2);

SWIGIMPORT inworld_HashSet_String* inworld_HashSet_String_copy(inworld_HashSet_String* carg1);

SWIGIMPORT inworld_HashMap_StringToHashSetString* inworld_HashMap_StringToHashSetString_new();

SWIGIMPORT void inworld_HashMap_StringToHashSetString_delete(inworld_HashMap_StringToHashSetString* carg1);

SWIGIMPORT size_t inworld_HashMap_StringToHashSetString_size(inworld_HashMap_StringToHashSetString* carg1);

SWIGIMPORT bool inworld_HashMap_StringToHashSetString_empty(inworld_HashMap_StringToHashSetString* carg1);

SWIGIMPORT void inworld_HashMap_StringToHashSetString_clear(inworld_HashMap_StringToHashSetString* carg1);

SWIGIMPORT inworld_HashSet_String* inworld_HashMap_StringToHashSetString___getitem__(inworld_HashMap_StringToHashSetString* carg1, const char * carg2);

SWIGIMPORT void inworld_HashMap_StringToHashSetString___setitem__(inworld_HashMap_StringToHashSetString* carg1, const char * carg2, inworld_HashSet_String* carg3);

SWIGIMPORT bool inworld_HashMap_StringToHashSetString___contains__(inworld_HashMap_StringToHashSetString* carg1, const char * carg2);

SWIGIMPORT inworld_HashMap_StringToHashSetString* inworld_HashMap_StringToHashSetString_copy(inworld_HashMap_StringToHashSetString* carg1);

SWIGIMPORT void inworld_Edge_to_node_id_set(inworld_Edge* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Edge_to_node_id_get(inworld_Edge* carg1);

SWIGIMPORT void inworld_Edge_is_required_set(inworld_Edge* carg1, bool carg2);

SWIGIMPORT bool inworld_Edge_is_required_get(inworld_Edge* carg1);

SWIGIMPORT void inworld_Edge_is_loop_edge_set(inworld_Edge* carg1, bool carg2);

SWIGIMPORT bool inworld_Edge_is_loop_edge_get(inworld_Edge* carg1);

SWIGIMPORT inworld_Edge* inworld_Edge_new();

SWIGIMPORT inworld_Edge* inworld_Edge_copy(inworld_Edge* carg1);

SWIGIMPORT void inworld_Edge_delete(inworld_Edge* carg1);

SWIGIMPORT void inworld_Loop_entry_node_id_set(inworld_Loop* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Loop_entry_node_id_get(inworld_Loop* carg1);

SWIGIMPORT void inworld_Loop_loop_paths_set(inworld_Loop* carg1, inworld_HashMap_StringToHashSetString* carg2);

SWIGIMPORT inworld_HashMap_StringToHashSetString* inworld_Loop_loop_paths_get(inworld_Loop* carg1);

SWIGIMPORT inworld_Loop* inworld_Loop_new();

SWIGIMPORT inworld_Loop* inworld_Loop_copy(inworld_Loop* carg1);

SWIGIMPORT void inworld_Loop_delete(inworld_Loop* carg1);

SWIGIMPORT inworld_HashMap_StringToNode* inworld_HashMap_StringToNode_new();

SWIGIMPORT void inworld_HashMap_StringToNode_delete(inworld_HashMap_StringToNode* carg1);

SWIGIMPORT size_t inworld_HashMap_StringToNode_size(inworld_HashMap_StringToNode* carg1);

SWIGIMPORT bool inworld_HashMap_StringToNode_empty(inworld_HashMap_StringToNode* carg1);

SWIGIMPORT void inworld_HashMap_StringToNode_clear(inworld_HashMap_StringToNode* carg1);

SWIGIMPORT inworld_Node* inworld_HashMap_StringToNode___getitem__(inworld_HashMap_StringToNode* carg1, const char * carg2);

SWIGIMPORT void inworld_HashMap_StringToNode___setitem__(inworld_HashMap_StringToNode* carg1, const char * carg2, inworld_Node* carg3);

SWIGIMPORT bool inworld_HashMap_StringToNode___contains__(inworld_HashMap_StringToNode* carg1, const char * carg2);

SWIGIMPORT inworld_HashMap_StringToNode* inworld_HashMap_StringToNode_copy(inworld_HashMap_StringToNode* carg1);

SWIGIMPORT inworld_HashMap_StringToLoop* inworld_HashMap_StringToLoop_new();

SWIGIMPORT void inworld_HashMap_StringToLoop_delete(inworld_HashMap_StringToLoop* carg1);

SWIGIMPORT size_t inworld_HashMap_StringToLoop_size(inworld_HashMap_StringToLoop* carg1);

SWIGIMPORT bool inworld_HashMap_StringToLoop_empty(inworld_HashMap_StringToLoop* carg1);

SWIGIMPORT void inworld_HashMap_StringToLoop_clear(inworld_HashMap_StringToLoop* carg1);

SWIGIMPORT inworld_Loop* inworld_HashMap_StringToLoop___getitem__(inworld_HashMap_StringToLoop* carg1, const char * carg2);

SWIGIMPORT void inworld_HashMap_StringToLoop___setitem__(inworld_HashMap_StringToLoop* carg1, const char * carg2, inworld_Loop* carg3);

SWIGIMPORT bool inworld_HashMap_StringToLoop___contains__(inworld_HashMap_StringToLoop* carg1, const char * carg2);

SWIGIMPORT inworld_HashMap_StringToLoop* inworld_HashMap_StringToLoop_copy(inworld_HashMap_StringToLoop* carg1);

SWIGIMPORT void inworld_CompiledGraphInterface_delete(inworld_CompiledGraphInterface* carg1);

SWIGIMPORT const char * inworld_CompiledGraphInterface_id(inworld_CompiledGraphInterface* carg1);

SWIGIMPORT inworld_HashMap_StringToNode* inworld_CompiledGraphInterface_Nodes(inworld_CompiledGraphInterface* carg1);

SWIGIMPORT inworld_HashSet_String* inworld_CompiledGraphInterface_StartNodes(inworld_CompiledGraphInterface* carg1);

SWIGIMPORT inworld_HashSet_String* inworld_CompiledGraphInterface_EndNodes(inworld_CompiledGraphInterface* carg1);

SWIGIMPORT inworld_HashMap_StringToLoop* inworld_CompiledGraphInterface_Loops(inworld_CompiledGraphInterface* carg1);

SWIGIMPORT inworld_vector_Edge* inworld_CompiledGraphInterface_Edges(inworld_CompiledGraphInterface* carg1, const char * carg2);

SWIGIMPORT inworld_vector_string* inworld_CompiledGraphInterface_ParentNodeIds(inworld_CompiledGraphInterface* carg1, const char * carg2);

SWIGIMPORT inworld_Status* inworld_CompiledGraphInterface_Visualize(inworld_CompiledGraphInterface* carg1, const char * carg2);

SWIGIMPORT inworld_DataStore* inworld_DataStore_new();

SWIGIMPORT void inworld_DataStore_delete(inworld_DataStore* carg1);

SWIGIMPORT bool inworld_DataStore_Add(inworld_DataStore* carg1, const char * carg2, inworld_BaseData* carg3);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_DataStore_Get(inworld_DataStore* carg1, const char * carg2);

SWIGIMPORT inworld_BaseData* inworld_DataStore_GetOrDefault(inworld_DataStore* carg1, const char * carg2, inworld_BaseData* carg3);

SWIGIMPORT bool inworld_DataStore_Contains(inworld_DataStore* carg1, const char * carg2);

SWIGIMPORT inworld_vector_string* inworld_DataStore_GetKeys(inworld_DataStore* carg1);

SWIGIMPORT size_t inworld_DataStore_Size(inworld_DataStore* carg1);

SWIGIMPORT bool inworld_DataStore_Empty(inworld_DataStore* carg1);

SWIGIMPORT bool inworld_DataStore_is_valid(inworld_DataStore* carg1);

SWIGIMPORT inworld_EdgeContext* inworld_EdgeContext_Create(const char * carg1, inworld_DataStore* carg2, inworld_CancellationContext* carg3);

SWIGIMPORT void inworld_EdgeContext_delete(inworld_EdgeContext* carg1);

SWIGIMPORT const char * inworld_EdgeContext_GetExecutionId(inworld_EdgeContext* carg1);

SWIGIMPORT inworld_DataStore* inworld_EdgeContext_GetDataStore(inworld_EdgeContext* carg1);

SWIGIMPORT bool inworld_EdgeContext_IsCancelled(inworld_EdgeContext* carg1);

SWIGIMPORT inworld_CancellationContext* inworld_EdgeContext_GetCancellationContext(inworld_EdgeContext* carg1);

SWIGIMPORT bool inworld_EdgeContext_is_valid(inworld_EdgeContext* carg1);

SWIGIMPORT inworld_StatusOr_CompiledGraphInterfacePtr* inworld_StatusOr_CompiledGraphInterfacePtr_new();

SWIGIMPORT inworld_StatusOr_CompiledGraphInterfacePtr* inworld_StatusOr_CompiledGraphInterfacePtr_new_rcpinworld_graphs_CompiledGraphInterface(inworld_CompiledGraphInterface* carg1);

SWIGIMPORT inworld_StatusOr_CompiledGraphInterfacePtr* inworld_StatusOr_CompiledGraphInterfacePtr_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_CompiledGraphInterfacePtr_ok(inworld_StatusOr_CompiledGraphInterfacePtr* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_CompiledGraphInterfacePtr_status(inworld_StatusOr_CompiledGraphInterfacePtr* carg1);

SWIGIMPORT inworld_CompiledGraphInterface* inworld_StatusOr_CompiledGraphInterfacePtr_value(inworld_StatusOr_CompiledGraphInterfacePtr* carg1);

SWIGIMPORT inworld_StatusOr_CompiledGraphInterfacePtr* inworld_StatusOr_CompiledGraphInterfacePtr_copy(inworld_StatusOr_CompiledGraphInterfacePtr* carg1);

SWIGIMPORT void inworld_StatusOr_CompiledGraphInterfacePtr_delete(inworld_StatusOr_CompiledGraphInterfacePtr* carg1);

SWIGIMPORT inworld_StatusOr_ConfigParserPtr* inworld_StatusOr_ConfigParserPtr_new();

SWIGIMPORT inworld_StatusOr_ConfigParserPtr* inworld_StatusOr_ConfigParserPtr_new_rcpinworld_graphs_ConfigParser(inworld_ConfigParser* carg1);

SWIGIMPORT inworld_StatusOr_ConfigParserPtr* inworld_StatusOr_ConfigParserPtr_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_ConfigParserPtr_ok(inworld_StatusOr_ConfigParserPtr* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_ConfigParserPtr_status(inworld_StatusOr_ConfigParserPtr* carg1);

SWIGIMPORT inworld_ConfigParser* inworld_StatusOr_ConfigParserPtr_value(inworld_StatusOr_ConfigParserPtr* carg1);

SWIGIMPORT inworld_StatusOr_ConfigParserPtr* inworld_StatusOr_ConfigParserPtr_copy(inworld_StatusOr_ConfigParserPtr* carg1);

SWIGIMPORT void inworld_StatusOr_ConfigParserPtr_delete(inworld_StatusOr_ConfigParserPtr* carg1);

SWIGIMPORT void inworld_ConfigParser_delete(inworld_ConfigParser* carg1);

SWIGIMPORT inworld_StatusOr_ConfigParserPtr* inworld_ConfigParser_CreateConfigParser();

SWIGIMPORT inworld_StatusOr_ConfigParserPtr* inworld_ConfigParser_CreateConfigParserWithDefaults(inworld_HashMap_StringToString* carg1);

SWIGIMPORT inworld_StatusOr_CompiledGraphInterfacePtr* inworld_ConfigParser_ParseGraphFromJsonString(inworld_ConfigParser* carg1, const char * carg2);

SWIGIMPORT inworld_StatusOr_CompiledGraphInterfacePtr* inworld_ConfigParser_ParseGraphFromJsonStringWithSubstitutions(inworld_ConfigParser* carg1, const char * carg2, inworld_HashMap_StringToString* carg3);

SWIGIMPORT inworld_Graph* inworld_Graph_new(const char * carg1);

SWIGIMPORT void inworld_Graph_delete(inworld_Graph* carg1);

SWIGIMPORT void inworld_Graph_AddNode(inworld_Graph* carg1, inworld_Node* carg2);

SWIGIMPORT void inworld_Graph_SetAsStart(inworld_Graph* carg1, inworld_Node* carg2);

SWIGIMPORT void inworld_Graph_SetAsEnd(inworld_Graph* carg1, inworld_Node* carg2);

SWIGIMPORT inworld_StatusOr_CompiledGraphInterfacePtr* inworld_Graph_CompileAndReturnRaw(inworld_Graph* carg1);

SWIGIMPORT inworld_EdgeWrapper* inworld_Graph_CreateEdge(inworld_Graph* carg1, inworld_Node* carg2, inworld_Node* carg3);

SWIGIMPORT inworld_StatusOr_CreationContext* inworld_Graph_GetCreationContextHelper(inworld_Graph* carg1);

SWIGIMPORT inworld_Status* inworld_Graph_AddComponent_LLMInterface(inworld_Graph* carg1, const char * carg2, inworld_LLMInterface* carg3);

SWIGIMPORT inworld_Status* inworld_Graph_AddComponent_STTInterface(inworld_Graph* carg1, const char * carg2, inworld_STTInterface* carg3);

SWIGIMPORT inworld_Status* inworld_Graph_AddComponent_StreamingSTTInterface(inworld_Graph* carg1, const char * carg2, inworld_StreamingSTTInterface* carg3);

SWIGIMPORT inworld_Status* inworld_Graph_AddComponent_TTSInterface(inworld_Graph* carg1, const char * carg2, inworld_TTSInterface* carg3);

SWIGIMPORT inworld_Status* inworld_Graph_AddComponent_TextEmbedderInterface(inworld_Graph* carg1, const char * carg2, inworld_TextEmbedderInterface* carg3);

SWIGIMPORT inworld_Status* inworld_Graph_AddComponent_KnowledgeInterface(inworld_Graph* carg1, const char * carg2, inworld_KnowledgeInterface* carg3);

SWIGIMPORT inworld_Status* inworld_Graph_AddComponent_MCPClientInterface(inworld_Graph* carg1, const char * carg2, inworld_MCPClientInterface* carg3);

SWIGIMPORT inworld_EdgeConditionExecutor* inworld_EdgeConditionExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT inworld_EdgeConditionExecutor* inworld_EdgeConditionExecutor_copy(inworld_EdgeConditionExecutor* carg1);

SWIGIMPORT inworld_EdgeContext* inworld_EdgeConditionExecutor_GetLastEdgeContext();

SWIGIMPORT inworld_BaseData* inworld_EdgeConditionExecutor_GetLastInput();

SWIGIMPORT void inworld_EdgeConditionExecutor_SetNextOutput(bool carg1);

SWIGIMPORT void inworld_EdgeConditionExecutor_SetNextError(const char * carg1);

SWIGIMPORT void inworld_EdgeConditionExecutor_delete(inworld_EdgeConditionExecutor* carg1);

SWIGIMPORT inworld_EdgeConditionThreadedExecutor* inworld_EdgeConditionThreadedExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_EdgeConditionThreadedExecutor_delete(inworld_EdgeConditionThreadedExecutor* carg1);

SWIGIMPORT inworld_BaseData* inworld_EdgeConditionThreadedExecutor_GetInput(int carg1);

SWIGIMPORT inworld_EdgeContext* inworld_EdgeConditionThreadedExecutor_GetEdgeContext(int carg1);

SWIGIMPORT void inworld_EdgeConditionThreadedExecutor_SetOutput(int carg1, bool carg2);

SWIGIMPORT void inworld_EdgeConditionThreadedExecutor_SetError(int carg1, const char * carg2);

SWIGIMPORT inworld_EdgeConditionThreadedExecutor* inworld_EdgeConditionThreadedExecutor_copy(inworld_EdgeConditionThreadedExecutor* carg1);

SWIGIMPORT inworld_EdgeWrapper* inworld_EdgeWrapper_copy(inworld_EdgeWrapper* carg1);

SWIGIMPORT void inworld_EdgeWrapper_SetCondition_rcinworld_swig_helpers_EdgeConditionExecutor(inworld_EdgeWrapper* carg1, inworld_EdgeConditionExecutor* carg2);

SWIGIMPORT void inworld_EdgeWrapper_SetCondition_rcinworld_swig_helpers_EdgeConditionThreadedExecutor(inworld_EdgeWrapper* carg1, inworld_EdgeConditionThreadedExecutor* carg2);

SWIGIMPORT void inworld_EdgeWrapper_SetToOptional(inworld_EdgeWrapper* carg1);

SWIGIMPORT void inworld_EdgeWrapper_SetToLoop(inworld_EdgeWrapper* carg1);

SWIGIMPORT void inworld_EdgeWrapper_Build(inworld_EdgeWrapper* carg1);

SWIGIMPORT void inworld_EdgeWrapper_delete(inworld_EdgeWrapper* carg1);

SWIGIMPORT void inworld_MCPClientInterface_delete(inworld_MCPClientInterface* carg1);

SWIGIMPORT inworld_StatusOr_Tools* inworld_MCPClientInterface_ListTools(inworld_MCPClientInterface* carg1);

SWIGIMPORT bool inworld_MCPClientInterface_is_valid(inworld_MCPClientInterface* carg1);

SWIGIMPORT inworld_StatusOr_string* inworld_MCPClientInterface_Call(inworld_MCPClientInterface* carg1, inworld_ToolCall* carg2);

SWIGIMPORT inworld_vector_Node* inworld_vector_Node_new();

SWIGIMPORT inworld_vector_Node* inworld_vector_Node_copy(inworld_vector_Node* carg1);

SWIGIMPORT size_t inworld_vector_Node_size(inworld_vector_Node* carg1);

SWIGIMPORT size_t inworld_vector_Node_capacity(inworld_vector_Node* carg1);

SWIGIMPORT void inworld_vector_Node_reserve(inworld_vector_Node* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_Node_empty(inworld_vector_Node* carg1);

SWIGIMPORT void inworld_vector_Node_clear(inworld_vector_Node* carg1);

SWIGIMPORT void inworld_vector_Node_push_back(inworld_vector_Node* carg1, inworld_Node* carg2);

SWIGIMPORT inworld_Node* inworld_vector_Node_get(inworld_vector_Node* carg1, int carg2);

SWIGIMPORT void inworld_vector_Node_set(inworld_vector_Node* carg1, int carg2, inworld_Node* carg3);

SWIGIMPORT void inworld_vector_Node_delete(inworld_vector_Node* carg1);

SWIGIMPORT inworld_LinearGraph* inworld_LinearGraph_new(const char * carg1, inworld_vector_Node* carg2);

SWIGIMPORT void inworld_LinearGraph_delete(inworld_LinearGraph* carg1);

SWIGIMPORT void inworld_LinearGraph_AddNode(inworld_LinearGraph* carg1, inworld_Node* carg2);

SWIGIMPORT inworld_StatusOr_CreationContext* inworld_LinearGraph_GetCreationContextHelper(inworld_LinearGraph* carg1);

SWIGIMPORT inworld_Status* inworld_LinearGraph_AddComponent_LLMInterface(inworld_LinearGraph* carg1, const char * carg2, inworld_LLMInterface* carg3);

SWIGIMPORT inworld_Status* inworld_LinearGraph_AddComponent_STTInterface(inworld_LinearGraph* carg1, const char * carg2, inworld_STTInterface* carg3);

SWIGIMPORT inworld_Status* inworld_LinearGraph_AddComponent_StreamingSTTInterface(inworld_LinearGraph* carg1, const char * carg2, inworld_StreamingSTTInterface* carg3);

SWIGIMPORT inworld_Status* inworld_LinearGraph_AddComponent_TTSInterface(inworld_LinearGraph* carg1, const char * carg2, inworld_TTSInterface* carg3);

SWIGIMPORT inworld_Status* inworld_LinearGraph_AddComponent_TextEmbedderInterface(inworld_LinearGraph* carg1, const char * carg2, inworld_TextEmbedderInterface* carg3);

SWIGIMPORT inworld_Status* inworld_LinearGraph_AddComponent_KnowledgeInterface(inworld_LinearGraph* carg1, const char * carg2, inworld_KnowledgeInterface* carg3);

SWIGIMPORT inworld_Status* inworld_LinearGraph_AddComponent_MCPClientInterface(inworld_LinearGraph* carg1, const char * carg2, inworld_MCPClientInterface* carg3);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_StatusOr_TTSOutput_new();

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_StatusOr_TTSOutput_new_rcinworld_graphs_TTSOutput(inworld_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_StatusOr_TTSOutput_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_TTSOutput_ok(inworld_StatusOr_TTSOutput* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_TTSOutput_status(inworld_StatusOr_TTSOutput* carg1);

SWIGIMPORT inworld_TTSOutput* inworld_StatusOr_TTSOutput_value(inworld_StatusOr_TTSOutput* carg1);

SWIGIMPORT inworld_StatusOr_TTSOutput* inworld_StatusOr_TTSOutput_copy(inworld_StatusOr_TTSOutput* carg1);

SWIGIMPORT void inworld_StatusOr_TTSOutput_delete(inworld_StatusOr_TTSOutput* carg1);

SWIGIMPORT inworld_DataStream_TTSOutput* inworld_DataStream_TTSOutput_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_graphs_ProcessContext(inworld_InputStream_TTSOutput* carg1, inworld_ProcessContext* carg2);

SWIGIMPORT inworld_DataStream_TTSOutput* inworld_DataStream_TTSOutput_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg_(inworld_InputStream_TTSOutput* carg1);

SWIGIMPORT void inworld_DataStream_TTSOutput_delete(inworld_DataStream_TTSOutput* carg1);

SWIGIMPORT inworld_DataStream_TTSOutput* inworld_DataStream_TTSOutput_copy(inworld_DataStream_TTSOutput* carg1);

SWIGIMPORT inworld_InputStream_TTSOutput* inworld_DataStream_TTSOutput_stream(inworld_DataStream_TTSOutput* carg1);

SWIGIMPORT inworld_CancellationContext* inworld_DataStream_TTSOutput_cancellation_context(inworld_DataStream_TTSOutput* carg1);

SWIGIMPORT bool inworld_DataStream_TTSOutput_is_valid(inworld_DataStream_TTSOutput* carg1);

SWIGIMPORT const char * inworld_DataStream_TTSOutput_ToString(inworld_DataStream_TTSOutput* carg1);

SWIGIMPORT inworld_DataStream_String* inworld_DataStream_String_new_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_graphs_ProcessContext(inworld_InputStream_string* carg1, inworld_ProcessContext* carg2);

SWIGIMPORT inworld_DataStream_String* inworld_DataStream_String_new_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg_(inworld_InputStream_string* carg1);

SWIGIMPORT void inworld_DataStream_String_delete(inworld_DataStream_String* carg1);

SWIGIMPORT inworld_DataStream_String* inworld_DataStream_String_copy(inworld_DataStream_String* carg1);

SWIGIMPORT inworld_InputStream_string* inworld_DataStream_String_stream(inworld_DataStream_String* carg1);

SWIGIMPORT inworld_CancellationContext* inworld_DataStream_String_cancellation_context(inworld_DataStream_String* carg1);

SWIGIMPORT bool inworld_DataStream_String_is_valid(inworld_DataStream_String* carg1);

SWIGIMPORT const char * inworld_DataStream_String_ToString(inworld_DataStream_String* carg1);

SWIGIMPORT inworld_DataStream_Content* inworld_DataStream_Content_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_graphs_ProcessContext(inworld_InputStream_Content* carg1, inworld_ProcessContext* carg2);

SWIGIMPORT inworld_DataStream_Content* inworld_DataStream_Content_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg_(inworld_InputStream_Content* carg1);

SWIGIMPORT void inworld_DataStream_Content_delete(inworld_DataStream_Content* carg1);

SWIGIMPORT inworld_DataStream_Content* inworld_DataStream_Content_copy(inworld_DataStream_Content* carg1);

SWIGIMPORT inworld_InputStream_Content* inworld_DataStream_Content_stream(inworld_DataStream_Content* carg1);

SWIGIMPORT inworld_CancellationContext* inworld_DataStream_Content_cancellation_context(inworld_DataStream_Content* carg1);

SWIGIMPORT bool inworld_DataStream_Content_is_valid(inworld_DataStream_Content* carg1);

SWIGIMPORT const char * inworld_DataStream_Content_ToString(inworld_DataStream_Content* carg1);

SWIGIMPORT inworld_DataStream_AudioChunk* inworld_DataStream_AudioChunk_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_graphs_ProcessContext(inworld_InputStream_AudioChunk* carg1, inworld_ProcessContext* carg2);

SWIGIMPORT inworld_DataStream_AudioChunk* inworld_DataStream_AudioChunk_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg_(inworld_InputStream_AudioChunk* carg1);

SWIGIMPORT void inworld_DataStream_AudioChunk_delete(inworld_DataStream_AudioChunk* carg1);

SWIGIMPORT inworld_DataStream_AudioChunk* inworld_DataStream_AudioChunk_copy(inworld_DataStream_AudioChunk* carg1);

SWIGIMPORT inworld_InputStream_AudioChunk* inworld_DataStream_AudioChunk_stream(inworld_DataStream_AudioChunk* carg1);

SWIGIMPORT inworld_CancellationContext* inworld_DataStream_AudioChunk_cancellation_context(inworld_DataStream_AudioChunk* carg1);

SWIGIMPORT bool inworld_DataStream_AudioChunk_is_valid(inworld_DataStream_AudioChunk* carg1);

SWIGIMPORT const char * inworld_DataStream_AudioChunk_ToString(inworld_DataStream_AudioChunk* carg1);

SWIGIMPORT inworld_DataStream_BaseData* inworld_DataStream_BaseData_new_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_graphs_ProcessContext(inworld_InputStream_BaseData* carg1, inworld_ProcessContext* carg2);

SWIGIMPORT inworld_DataStream_BaseData* inworld_DataStream_BaseData_new_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg_(inworld_InputStream_BaseData* carg1);

SWIGIMPORT void inworld_DataStream_BaseData_delete(inworld_DataStream_BaseData* carg1);

SWIGIMPORT inworld_DataStream_BaseData* inworld_DataStream_BaseData_copy(inworld_DataStream_BaseData* carg1);

SWIGIMPORT inworld_InputStream_BaseData* inworld_DataStream_BaseData_stream(inworld_DataStream_BaseData* carg1);

SWIGIMPORT inworld_CancellationContext* inworld_DataStream_BaseData_cancellation_context(inworld_DataStream_BaseData* carg1);

SWIGIMPORT bool inworld_DataStream_BaseData_is_valid(inworld_DataStream_BaseData* carg1);

SWIGIMPORT const char * inworld_DataStream_BaseData_ToString(inworld_DataStream_BaseData* carg1);

SWIGIMPORT inworld_DataStream_TTSOutput* inworld_BaseDataAs_DataStream_TTSOutput(inworld_BaseData* carg1);

SWIGIMPORT inworld_DataStream_String* inworld_BaseDataAs_DataStream_String(inworld_BaseData* carg1);

SWIGIMPORT inworld_DataStream_Content* inworld_BaseDataAs_DataStream_Content(inworld_BaseData* carg1);

SWIGIMPORT inworld_DataStream_AudioChunk* inworld_BaseDataAs_DataStream_AudioChunk(inworld_BaseData* carg1);

SWIGIMPORT inworld_DataStream_BaseData* inworld_BaseDataAs_DataStream_BaseData(inworld_BaseData* carg1);

SWIGIMPORT inworld_EventHistory* inworld_EventHistory_new();

SWIGIMPORT inworld_EventHistory* inworld_EventHistory_new_std_vector_Sl_inworld_Event_Sg_(inworld_vector_Event* carg1);

SWIGIMPORT inworld_vector_Event* inworld_EventHistory_events(inworld_EventHistory* carg1);

SWIGIMPORT bool inworld_EventHistory_is_valid(inworld_EventHistory* carg1);

SWIGIMPORT inworld_EventHistory* inworld_EventHistory_copy(inworld_EventHistory* carg1);

SWIGIMPORT void inworld_EventHistory_delete(inworld_EventHistory* carg1);

SWIGIMPORT const char * inworld_EventHistory_ToString(inworld_EventHistory* carg1);

SWIGIMPORT inworld_EventHistory* inworld_BaseDataAs_EventHistory(inworld_BaseData* carg1);

SWIGIMPORT inworld_StatusOr_CustomNodeWrapper* inworld_StatusOr_CustomNodeWrapper_new();

SWIGIMPORT inworld_StatusOr_CustomNodeWrapper* inworld_StatusOr_CustomNodeWrapper_new_rcstd_shared_ptr_Sl_inworld_swig_helpers_CustomNodeWrapper_Sg_(inworld_CustomNodeWrapper* carg1);

SWIGIMPORT inworld_StatusOr_CustomNodeWrapper* inworld_StatusOr_CustomNodeWrapper_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_CustomNodeWrapper_ok(inworld_StatusOr_CustomNodeWrapper* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_CustomNodeWrapper_status(inworld_StatusOr_CustomNodeWrapper* carg1);

SWIGIMPORT inworld_CustomNodeWrapper* inworld_StatusOr_CustomNodeWrapper_value(inworld_StatusOr_CustomNodeWrapper* carg1);

SWIGIMPORT inworld_StatusOr_CustomNodeWrapper* inworld_StatusOr_CustomNodeWrapper_copy(inworld_StatusOr_CustomNodeWrapper* carg1);

SWIGIMPORT void inworld_StatusOr_CustomNodeWrapper_delete(inworld_StatusOr_CustomNodeWrapper* carg1);

SWIGIMPORT inworld_CustomNodeThreadedCreateExecutor* inworld_CustomNodeThreadedCreateExecutor_new_pv_pv(void * carg1, void * carg2);

SWIGIMPORT void inworld_CustomNodeThreadedCreateExecutor_delete(inworld_CustomNodeThreadedCreateExecutor* carg1);

SWIGIMPORT const char * inworld_CustomNodeThreadedCreateExecutor_GetInputId(int carg1);

SWIGIMPORT inworld_CreationContext* inworld_CustomNodeThreadedCreateExecutor_GetInputCreationContext(int carg1);

SWIGIMPORT inworld_CustomExecutionConfigWrapper* inworld_CustomNodeThreadedCreateExecutor_GetInputExecutionConfig(int carg1);

SWIGIMPORT inworld_vector_CustomConfigWrapper* inworld_CustomNodeThreadedCreateExecutor_GetInputConfigs(int carg1);

SWIGIMPORT void inworld_CustomNodeThreadedCreateExecutor_SetOutput(int carg1, inworld_StatusOr_CustomNodeWrapper* carg2);

SWIGIMPORT inworld_CustomNodeThreadedCreateExecutor* inworld_CustomNodeThreadedCreateExecutor_copy(inworld_CustomNodeThreadedCreateExecutor* carg1);

SWIGIMPORT inworld_HashMap_StringToString* inworld_HashMap_StringToString_new();

SWIGIMPORT void inworld_HashMap_StringToString_delete(inworld_HashMap_StringToString* carg1);

SWIGIMPORT size_t inworld_HashMap_StringToString_size(inworld_HashMap_StringToString* carg1);

SWIGIMPORT bool inworld_HashMap_StringToString_empty(inworld_HashMap_StringToString* carg1);

SWIGIMPORT void inworld_HashMap_StringToString_clear(inworld_HashMap_StringToString* carg1);

SWIGIMPORT char * inworld_HashMap_StringToString___getitem__(inworld_HashMap_StringToString* carg1, const char * carg2);

SWIGIMPORT void inworld_HashMap_StringToString___setitem__(inworld_HashMap_StringToString* carg1, const char * carg2, const char * carg3);

SWIGIMPORT bool inworld_HashMap_StringToString___contains__(inworld_HashMap_StringToString* carg1, const char * carg2);

SWIGIMPORT inworld_HashMap_StringToString* inworld_HashMap_StringToString_copy(inworld_HashMap_StringToString* carg1);

SWIGIMPORT inworld_BTreeMap_StringToString* inworld_BTreeMap_StringToString_new();

SWIGIMPORT void inworld_BTreeMap_StringToString_delete(inworld_BTreeMap_StringToString* carg1);

SWIGIMPORT size_t inworld_BTreeMap_StringToString_size(inworld_BTreeMap_StringToString* carg1);

SWIGIMPORT bool inworld_BTreeMap_StringToString_empty(inworld_BTreeMap_StringToString* carg1);

SWIGIMPORT void inworld_BTreeMap_StringToString_clear(inworld_BTreeMap_StringToString* carg1);

SWIGIMPORT char * inworld_BTreeMap_StringToString___getitem__(inworld_BTreeMap_StringToString* carg1, const char * carg2);

SWIGIMPORT void inworld_BTreeMap_StringToString___setitem__(inworld_BTreeMap_StringToString* carg1, const char * carg2, const char * carg3);

SWIGIMPORT bool inworld_BTreeMap_StringToString___contains__(inworld_BTreeMap_StringToString* carg1, const char * carg2);

SWIGIMPORT inworld_BTreeMap_StringToString* inworld_BTreeMap_StringToString_copy(inworld_BTreeMap_StringToString* carg1);

SWIGIMPORT inworld_HashMap_StringToBaseData* inworld_HashMap_StringToBaseData_new();

SWIGIMPORT void inworld_HashMap_StringToBaseData_delete(inworld_HashMap_StringToBaseData* carg1);

SWIGIMPORT size_t inworld_HashMap_StringToBaseData_size(inworld_HashMap_StringToBaseData* carg1);

SWIGIMPORT bool inworld_HashMap_StringToBaseData_empty(inworld_HashMap_StringToBaseData* carg1);

SWIGIMPORT void inworld_HashMap_StringToBaseData_clear(inworld_HashMap_StringToBaseData* carg1);

SWIGIMPORT inworld_BaseData* inworld_HashMap_StringToBaseData___getitem__(inworld_HashMap_StringToBaseData* carg1, const char * carg2);

SWIGIMPORT void inworld_HashMap_StringToBaseData___setitem__(inworld_HashMap_StringToBaseData* carg1, const char * carg2, inworld_BaseData* carg3);

SWIGIMPORT bool inworld_HashMap_StringToBaseData___contains__(inworld_HashMap_StringToBaseData* carg1, const char * carg2);

SWIGIMPORT inworld_HashMap_StringToBaseData* inworld_HashMap_StringToBaseData_copy(inworld_HashMap_StringToBaseData* carg1);

SWIGIMPORT inworld_OptionalHashMapStringToBaseData* inworld_OptionalHashMapStringToBaseData_new();

SWIGIMPORT inworld_OptionalHashMapStringToBaseData* inworld_OptionalHashMapStringToBaseData_new_rcabsl_flat_hash_map_Sl_std_string_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg_(inworld_HashMap_StringToBaseData* carg1);

SWIGIMPORT inworld_OptionalHashMapStringToBaseData* inworld_OptionalHashMapStringToBaseData_copy(inworld_OptionalHashMapStringToBaseData* carg1);

SWIGIMPORT void inworld_OptionalHashMapStringToBaseData_delete(inworld_OptionalHashMapStringToBaseData* carg1);

SWIGIMPORT bool inworld_OptionalHashMapStringToBaseData_has_value(inworld_OptionalHashMapStringToBaseData* carg1);

SWIGIMPORT inworld_HashMap_StringToBaseData* inworld_OptionalHashMapStringToBaseData_value(inworld_OptionalHashMapStringToBaseData* carg1);

SWIGIMPORT inworld_HashMap_StringToBaseData* inworld_OptionalHashMapStringToBaseData_valueConst(inworld_OptionalHashMapStringToBaseData* carg1);

SWIGIMPORT inworld_HashMap_StringToBaseData* inworld_OptionalHashMapStringToBaseData_value_or(inworld_OptionalHashMapStringToBaseData* carg1, inworld_HashMap_StringToBaseData* carg2);

SWIGIMPORT void inworld_OptionalHashMapStringToBaseData_reset(inworld_OptionalHashMapStringToBaseData* carg1);

SWIGIMPORT inworld_HashMap_StringToBaseData* inworld_OptionalHashMapStringToBaseData_get(inworld_OptionalHashMapStringToBaseData* carg1);

SWIGIMPORT inworld_HashMap_StringToBaseData* inworld_OptionalHashMapStringToBaseData_getConst(inworld_OptionalHashMapStringToBaseData* carg1);

SWIGIMPORT inworld_HashMap_StringToBaseData* inworld_OptionalHashMapStringToBaseData_get_value(inworld_OptionalHashMapStringToBaseData* carg1);

SWIGIMPORT void inworld_OptionalHashMapStringToBaseData_set_value(inworld_OptionalHashMapStringToBaseData* carg1, inworld_HashMap_StringToBaseData* carg2);

SWIGIMPORT inworld_StatusOr_ResultItem* inworld_StatusOr_ResultItem_new();

SWIGIMPORT inworld_StatusOr_ResultItem* inworld_StatusOr_ResultItem_new_rcinworld_graphs_ResultItem(inworld_ResultItem* carg1);

SWIGIMPORT inworld_StatusOr_ResultItem* inworld_StatusOr_ResultItem_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_ResultItem_ok(inworld_StatusOr_ResultItem* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_ResultItem_status(inworld_StatusOr_ResultItem* carg1);

SWIGIMPORT inworld_ResultItem* inworld_StatusOr_ResultItem_value(inworld_StatusOr_ResultItem* carg1);

SWIGIMPORT inworld_StatusOr_ResultItem* inworld_StatusOr_ResultItem_copy(inworld_StatusOr_ResultItem* carg1);

SWIGIMPORT void inworld_StatusOr_ResultItem_delete(inworld_StatusOr_ResultItem* carg1);

SWIGIMPORT void inworld_InputStream_ResultItem_delete(inworld_InputStream_ResultItem* carg1);

SWIGIMPORT bool inworld_InputStream_ResultItem_HasNext(inworld_InputStream_ResultItem* carg1);

SWIGIMPORT inworld_StatusOr_ResultItem* inworld_InputStream_ResultItem_Read(inworld_InputStream_ResultItem* carg1);

SWIGIMPORT void inworld_InputStream_ResultItem_Cancel(inworld_InputStream_ResultItem* carg1);

SWIGIMPORT bool inworld_InputStream_ResultItem_is_valid(inworld_InputStream_ResultItem* carg1);

SWIGIMPORT inworld_ResultItem* inworld_ResultItem_new_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__std_optional_Sl_std_string_Sg_(inworld_BaseData* carg1, inworld_optional_string* carg2);

SWIGIMPORT inworld_ResultItem* inworld_ResultItem_new_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg_(inworld_BaseData* carg1);

SWIGIMPORT void inworld_ResultItem_value_set(inworld_ResultItem* carg1, inworld_BaseData* carg2);

SWIGIMPORT inworld_BaseData* inworld_ResultItem_value_get(inworld_ResultItem* carg1);

SWIGIMPORT void inworld_ResultItem_node_id_set(inworld_ResultItem* carg1, inworld_optional_string* carg2);

SWIGIMPORT inworld_optional_string* inworld_ResultItem_node_id_get(inworld_ResultItem* carg1);

SWIGIMPORT inworld_BaseData* inworld_ResultItem_safe_value(inworld_ResultItem* carg1);

SWIGIMPORT inworld_ResultItem* inworld_ResultItem_copy(inworld_ResultItem* carg1);

SWIGIMPORT void inworld_ResultItem_delete(inworld_ResultItem* carg1);

SWIGIMPORT inworld_ExecutionResult* inworld_ExecutionResult_CreateEmpty_rcstd_string_rcstd_string(const char * carg1, const char * carg2);

SWIGIMPORT inworld_ExecutionResult* inworld_ExecutionResult_CreateEmpty_rcstd_string(const char * carg1);

SWIGIMPORT inworld_ExecutionResult* inworld_ExecutionResult_CreateEmpty();

SWIGIMPORT inworld_ExecutionResult* inworld_ExecutionResult_CreateWithError(inworld_Status* carg1, const char * carg2, const char * carg3);

SWIGIMPORT void inworld_ExecutionResult_delete(inworld_ExecutionResult* carg1);

SWIGIMPORT void inworld_ExecutionResult_Cancel(inworld_ExecutionResult* carg1);

SWIGIMPORT inworld_InputStream_ResultItem* inworld_ExecutionResult_GetResultStream(inworld_ExecutionResult* carg1);

SWIGIMPORT const char * inworld_ExecutionResult_GetVariant(inworld_ExecutionResult* carg1);

SWIGIMPORT const char * inworld_ExecutionResult_GetExecutionId(inworld_ExecutionResult* carg1);

SWIGIMPORT void inworld_UserContext_attributes_set(inworld_UserContext* carg1, inworld_BTreeMap_StringToString* carg2);

SWIGIMPORT inworld_BTreeMap_StringToString* inworld_UserContext_attributes_get(inworld_UserContext* carg1);

SWIGIMPORT void inworld_UserContext_targeting_key_set(inworld_UserContext* carg1, const char * carg2);

SWIGIMPORT const char * inworld_UserContext_targeting_key_get(inworld_UserContext* carg1);

SWIGIMPORT inworld_UserContext* inworld_UserContext_new();

SWIGIMPORT inworld_UserContext* inworld_UserContext_copy(inworld_UserContext* carg1);

SWIGIMPORT void inworld_UserContext_delete(inworld_UserContext* carg1);

SWIGIMPORT void inworld_ExecutionContext_execution_id_set(inworld_ExecutionContext* carg1, inworld_optional_string* carg2);

SWIGIMPORT inworld_optional_string* inworld_ExecutionContext_execution_id_get(inworld_ExecutionContext* carg1);

SWIGIMPORT void inworld_ExecutionContext_user_context_set(inworld_ExecutionContext* carg1, inworld_optional_UserContext* carg2);

SWIGIMPORT inworld_optional_UserContext* inworld_ExecutionContext_user_context_get(inworld_ExecutionContext* carg1);

SWIGIMPORT void inworld_ExecutionContext_data_to_store_set(inworld_ExecutionContext* carg1, inworld_OptionalHashMapStringToBaseData* carg2);

SWIGIMPORT inworld_OptionalHashMapStringToBaseData* inworld_ExecutionContext_data_to_store_get(inworld_ExecutionContext* carg1);

SWIGIMPORT inworld_ExecutionContext* inworld_ExecutionContext_Empty();

SWIGIMPORT inworld_ExecutionContext* inworld_ExecutionContext_new();

SWIGIMPORT inworld_ExecutionContext* inworld_ExecutionContext_copy(inworld_ExecutionContext* carg1);

SWIGIMPORT void inworld_ExecutionContext_delete(inworld_ExecutionContext* carg1);

SWIGIMPORT void inworld_ExecutorInterface_delete(inworld_ExecutorInterface* carg1);

SWIGIMPORT inworld_Status* inworld_ExecutorInterface_Start(inworld_ExecutorInterface* carg1);

SWIGIMPORT inworld_ExecutionResult* inworld_ExecutorInterface_Execute_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__rcinworld_graphs_ExecutionContext(inworld_ExecutorInterface* carg1, inworld_BaseData* carg2, inworld_ExecutionContext* carg3);

SWIGIMPORT inworld_ExecutionResult* inworld_ExecutorInterface_Execute_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg_(inworld_ExecutorInterface* carg1, inworld_BaseData* carg2);

SWIGIMPORT inworld_Status* inworld_ExecutorInterface_Stop(inworld_ExecutorInterface* carg1);

SWIGIMPORT inworld_StatusOr_ExecutorInterfacePtr* inworld_StatusOr_ExecutorInterfacePtr_new();

SWIGIMPORT inworld_StatusOr_ExecutorInterfacePtr* inworld_StatusOr_ExecutorInterfacePtr_new_rcpinworld_graphs_ExecutorInterface(inworld_ExecutorInterface* carg1);

SWIGIMPORT inworld_StatusOr_ExecutorInterfacePtr* inworld_StatusOr_ExecutorInterfacePtr_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_ExecutorInterfacePtr_ok(inworld_StatusOr_ExecutorInterfacePtr* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_ExecutorInterfacePtr_status(inworld_StatusOr_ExecutorInterfacePtr* carg1);

SWIGIMPORT inworld_ExecutorInterface* inworld_StatusOr_ExecutorInterfacePtr_value(inworld_StatusOr_ExecutorInterfacePtr* carg1);

SWIGIMPORT inworld_StatusOr_ExecutorInterfacePtr* inworld_StatusOr_ExecutorInterfacePtr_copy(inworld_StatusOr_ExecutorInterfacePtr* carg1);

SWIGIMPORT void inworld_StatusOr_ExecutorInterfacePtr_delete(inworld_StatusOr_ExecutorInterfacePtr* carg1);

SWIGIMPORT inworld_StatusOr_GraphExecutorFactoryPtr* inworld_StatusOr_GraphExecutorFactoryPtr_new();

SWIGIMPORT inworld_StatusOr_GraphExecutorFactoryPtr* inworld_StatusOr_GraphExecutorFactoryPtr_new_rcpinworld_graphs_GraphExecutorFactory(inworld_GraphExecutorFactory* carg1);

SWIGIMPORT inworld_StatusOr_GraphExecutorFactoryPtr* inworld_StatusOr_GraphExecutorFactoryPtr_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_GraphExecutorFactoryPtr_ok(inworld_StatusOr_GraphExecutorFactoryPtr* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_GraphExecutorFactoryPtr_status(inworld_StatusOr_GraphExecutorFactoryPtr* carg1);

SWIGIMPORT inworld_GraphExecutorFactory* inworld_StatusOr_GraphExecutorFactoryPtr_value(inworld_StatusOr_GraphExecutorFactoryPtr* carg1);

SWIGIMPORT inworld_StatusOr_GraphExecutorFactoryPtr* inworld_StatusOr_GraphExecutorFactoryPtr_copy(inworld_StatusOr_GraphExecutorFactoryPtr* carg1);

SWIGIMPORT void inworld_StatusOr_GraphExecutorFactoryPtr_delete(inworld_StatusOr_GraphExecutorFactoryPtr* carg1);

SWIGIMPORT inworld_Optional_ThreadPoolConfig* inworld_Optional_ThreadPoolConfig_new();

SWIGIMPORT inworld_Optional_ThreadPoolConfig* inworld_Optional_ThreadPoolConfig_new_rcinworld_graphs_ThreadPoolConfig(inworld_ThreadPoolConfig* carg1);

SWIGIMPORT inworld_Optional_ThreadPoolConfig* inworld_Optional_ThreadPoolConfig_copy(inworld_Optional_ThreadPoolConfig* carg1);

SWIGIMPORT void inworld_Optional_ThreadPoolConfig_delete(inworld_Optional_ThreadPoolConfig* carg1);

SWIGIMPORT bool inworld_Optional_ThreadPoolConfig_has_value(inworld_Optional_ThreadPoolConfig* carg1);

SWIGIMPORT inworld_ThreadPoolConfig* inworld_Optional_ThreadPoolConfig_value(inworld_Optional_ThreadPoolConfig* carg1);

SWIGIMPORT inworld_ThreadPoolConfig* inworld_Optional_ThreadPoolConfig_valueConst(inworld_Optional_ThreadPoolConfig* carg1);

SWIGIMPORT inworld_ThreadPoolConfig* inworld_Optional_ThreadPoolConfig_value_or(inworld_Optional_ThreadPoolConfig* carg1, inworld_ThreadPoolConfig* carg2);

SWIGIMPORT void inworld_Optional_ThreadPoolConfig_reset(inworld_Optional_ThreadPoolConfig* carg1);

SWIGIMPORT inworld_ThreadPoolConfig* inworld_Optional_ThreadPoolConfig_get(inworld_Optional_ThreadPoolConfig* carg1);

SWIGIMPORT inworld_ThreadPoolConfig* inworld_Optional_ThreadPoolConfig_getConst(inworld_Optional_ThreadPoolConfig* carg1);

SWIGIMPORT inworld_ThreadPoolConfig* inworld_Optional_ThreadPoolConfig_get_value(inworld_Optional_ThreadPoolConfig* carg1);

SWIGIMPORT void inworld_Optional_ThreadPoolConfig_set_value(inworld_Optional_ThreadPoolConfig* carg1, inworld_ThreadPoolConfig* carg2);

SWIGIMPORT void inworld_GraphManagerConfig_enable_remote_config_set(inworld_GraphManagerConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_GraphManagerConfig_enable_remote_config_get(inworld_GraphManagerConfig* carg1);

SWIGIMPORT void inworld_GraphManagerConfig_poll_interval_set(inworld_GraphManagerConfig* carg1, inworld_Duration* carg2);

SWIGIMPORT inworld_Duration* inworld_GraphManagerConfig_poll_interval_get(inworld_GraphManagerConfig* carg1);

SWIGIMPORT void inworld_GraphManagerConfig_address_set(inworld_GraphManagerConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_GraphManagerConfig_address_get(inworld_GraphManagerConfig* carg1);

SWIGIMPORT void inworld_GraphManagerConfig_inworld_api_key_set(inworld_GraphManagerConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_GraphManagerConfig_inworld_api_key_get(inworld_GraphManagerConfig* carg1);

SWIGIMPORT void inworld_GraphManagerConfig_evaluation_mode_set(inworld_GraphManagerConfig* carg1, enum inworld_GraphManagerConfig_EvaluationMode carg2);

SWIGIMPORT enum inworld_GraphManagerConfig_EvaluationMode inworld_GraphManagerConfig_evaluation_mode_get(inworld_GraphManagerConfig* carg1);

SWIGIMPORT void inworld_GraphManagerConfig_config_environment_variables_set(inworld_GraphManagerConfig* carg1, inworld_HashMap_StringToString* carg2);

SWIGIMPORT inworld_HashMap_StringToString* inworld_GraphManagerConfig_config_environment_variables_get(inworld_GraphManagerConfig* carg1);

SWIGIMPORT inworld_GraphManagerConfig* inworld_GraphManagerConfig_Default();

SWIGIMPORT inworld_GraphManagerConfig* inworld_GraphManagerConfig_WithDisabledRemoteConfig();

SWIGIMPORT inworld_GraphManagerConfig* inworld_GraphManagerConfig_WithRemoteConfig_rcstd_string_rcstd_string_absl_Duration_eEvaluationMode(const char * carg1, const char * carg2, inworld_Duration* carg3, enum inworld_GraphManagerConfig_EvaluationMode carg4);

SWIGIMPORT inworld_GraphManagerConfig* inworld_GraphManagerConfig_WithRemoteConfig_rcstd_string_rcstd_string_absl_Duration(const char * carg1, const char * carg2, inworld_Duration* carg3);

SWIGIMPORT inworld_GraphManagerConfig* inworld_GraphManagerConfig_WithRemoteConfig_rcstd_string_rcstd_string(const char * carg1, const char * carg2);

SWIGIMPORT inworld_GraphManagerConfig* inworld_GraphManagerConfig_new();

SWIGIMPORT inworld_GraphManagerConfig* inworld_GraphManagerConfig_copy(inworld_GraphManagerConfig* carg1);

SWIGIMPORT void inworld_GraphManagerConfig_delete(inworld_GraphManagerConfig* carg1);

SWIGIMPORT void inworld_ThreadPoolConfig_worker_strategy_set(inworld_ThreadPoolConfig* carg1, enum inworld_ThreadPoolConfig_WorkerCountStrategy carg2);

SWIGIMPORT enum inworld_ThreadPoolConfig_WorkerCountStrategy inworld_ThreadPoolConfig_worker_strategy_get(inworld_ThreadPoolConfig* carg1);

SWIGIMPORT void inworld_ThreadPoolConfig_thread_pool_strategy_set(inworld_ThreadPoolConfig* carg1, enum inworld_ThreadPoolConfig_ThreadPoolStrategy carg2);

SWIGIMPORT enum inworld_ThreadPoolConfig_ThreadPoolStrategy inworld_ThreadPoolConfig_thread_pool_strategy_get(inworld_ThreadPoolConfig* carg1);

SWIGIMPORT void inworld_ThreadPoolConfig_worker_count_set(inworld_ThreadPoolConfig* carg1, inworld_optional_sizet* carg2);

SWIGIMPORT inworld_optional_sizet* inworld_ThreadPoolConfig_worker_count_get(inworld_ThreadPoolConfig* carg1);

SWIGIMPORT void inworld_ThreadPoolConfig_core_multiplier_set(inworld_ThreadPoolConfig* carg1, float carg2);

SWIGIMPORT float inworld_ThreadPoolConfig_core_multiplier_get(inworld_ThreadPoolConfig* carg1);

SWIGIMPORT inworld_ThreadPoolConfig* inworld_ThreadPoolConfig_Default();

SWIGIMPORT inworld_ThreadPoolConfig* inworld_ThreadPoolConfig_WithFixedWorkers(size_t carg1);

SWIGIMPORT inworld_ThreadPoolConfig* inworld_ThreadPoolConfig_WithSystemCores_f(float carg1);

SWIGIMPORT inworld_ThreadPoolConfig* inworld_ThreadPoolConfig_WithSystemCores();

SWIGIMPORT inworld_ThreadPoolConfig* inworld_ThreadPoolConfig_new();

SWIGIMPORT inworld_ThreadPoolConfig* inworld_ThreadPoolConfig_copy(inworld_ThreadPoolConfig* carg1);

SWIGIMPORT void inworld_ThreadPoolConfig_delete(inworld_ThreadPoolConfig* carg1);

SWIGIMPORT void inworld_GraphExecutorFactoryConfig_thread_pool_strategy_set(inworld_GraphExecutorFactoryConfig* carg1, enum inworld_ThreadPoolConfig_ThreadPoolStrategy carg2);

SWIGIMPORT enum inworld_ThreadPoolConfig_ThreadPoolStrategy inworld_GraphExecutorFactoryConfig_thread_pool_strategy_get(inworld_GraphExecutorFactoryConfig* carg1);

SWIGIMPORT void inworld_GraphExecutorFactoryConfig_thread_pool_config_set(inworld_GraphExecutorFactoryConfig* carg1, inworld_ThreadPoolConfig* carg2);

SWIGIMPORT inworld_ThreadPoolConfig* inworld_GraphExecutorFactoryConfig_thread_pool_config_get(inworld_GraphExecutorFactoryConfig* carg1);

SWIGIMPORT inworld_GraphExecutorFactoryConfig* inworld_GraphExecutorFactoryConfig_Default();

SWIGIMPORT inworld_GraphExecutorFactoryConfig* inworld_GraphExecutorFactoryConfig_WithSharedThreadPool(inworld_ThreadPoolConfig* carg1);

SWIGIMPORT inworld_GraphExecutorFactoryConfig* inworld_GraphExecutorFactoryConfig_WithDedicatedThreadPool(inworld_ThreadPoolConfig* carg1);

SWIGIMPORT inworld_GraphExecutorFactoryConfig* inworld_GraphExecutorFactoryConfig_new();

SWIGIMPORT inworld_GraphExecutorFactoryConfig* inworld_GraphExecutorFactoryConfig_copy(inworld_GraphExecutorFactoryConfig* carg1);

SWIGIMPORT void inworld_GraphExecutorFactoryConfig_delete(inworld_GraphExecutorFactoryConfig* carg1);

SWIGIMPORT void inworld_GraphExecutorConfig_graph_manager_config_set(inworld_GraphExecutorConfig* carg1, inworld_GraphManagerConfig* carg2);

SWIGIMPORT inworld_GraphManagerConfig* inworld_GraphExecutorConfig_graph_manager_config_get(inworld_GraphExecutorConfig* carg1);

SWIGIMPORT void inworld_GraphExecutorConfig_thread_pool_config_override_set(inworld_GraphExecutorConfig* carg1, inworld_Optional_ThreadPoolConfig* carg2);

SWIGIMPORT inworld_Optional_ThreadPoolConfig* inworld_GraphExecutorConfig_thread_pool_config_override_get(inworld_GraphExecutorConfig* carg1);

SWIGIMPORT inworld_GraphExecutorConfig* inworld_GraphExecutorConfig_Default();

SWIGIMPORT inworld_GraphExecutorConfig* inworld_GraphExecutorConfig_WithGraphManager(inworld_GraphManagerConfig* carg1);

SWIGIMPORT inworld_GraphExecutorConfig* inworld_GraphExecutorConfig_WithLocalGraphManager();

SWIGIMPORT inworld_GraphExecutorConfig* inworld_GraphExecutorConfig_new();

SWIGIMPORT inworld_GraphExecutorConfig* inworld_GraphExecutorConfig_copy(inworld_GraphExecutorConfig* carg1);

SWIGIMPORT void inworld_GraphExecutorConfig_delete(inworld_GraphExecutorConfig* carg1);

SWIGIMPORT void inworld_GraphExecutorFactory_delete(inworld_GraphExecutorFactory* carg1);

SWIGIMPORT inworld_StatusOr_GraphExecutorFactoryPtr* inworld_GraphExecutorFactory_CreateHelper();

SWIGIMPORT inworld_StatusOr_GraphExecutorFactoryPtr* inworld_GraphExecutorFactory_CreateHelper_rcinworld_graphs_GraphExecutorFactoryConfig(inworld_GraphExecutorFactoryConfig* carg1);

SWIGIMPORT inworld_StatusOr_ExecutorInterfacePtr* inworld_GraphExecutorFactory_CreateExecutorHelper_pinworld_graphs_CompiledGraphInterface(inworld_GraphExecutorFactory* carg1, inworld_CompiledGraphInterface* carg2);

SWIGIMPORT inworld_StatusOr_ExecutorInterfacePtr* inworld_GraphExecutorFactory_CreateExecutorHelper_pinworld_graphs_CompiledGraphInterface_rcinworld_graphs_GraphExecutorConfig(inworld_GraphExecutorFactory* carg1, inworld_CompiledGraphInterface* carg2, inworld_GraphExecutorConfig* carg3);

SWIGIMPORT void inworld_FeedbackRecorder_RecordFeedback(const char * carg1, const char * carg2, const char * carg3, const char * carg4);

SWIGIMPORT inworld_FeedbackRecorder* inworld_FeedbackRecorder_copy(inworld_FeedbackRecorder* carg1);

SWIGIMPORT void inworld_MCPHttpAuthConfig_api_key_set(inworld_MCPHttpAuthConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MCPHttpAuthConfig_api_key_get(inworld_MCPHttpAuthConfig* carg1);

SWIGIMPORT inworld_MCPHttpAuthConfig* inworld_MCPHttpAuthConfig_new();

SWIGIMPORT inworld_MCPHttpAuthConfig* inworld_MCPHttpAuthConfig_copy(inworld_MCPHttpAuthConfig* carg1);

SWIGIMPORT void inworld_MCPHttpAuthConfig_delete(inworld_MCPHttpAuthConfig* carg1);

SWIGIMPORT void inworld_ParagonApiAuthConfig_jwt_token_set(inworld_ParagonApiAuthConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_ParagonApiAuthConfig_jwt_token_get(inworld_ParagonApiAuthConfig* carg1);

SWIGIMPORT inworld_ParagonApiAuthConfig* inworld_ParagonApiAuthConfig_new();

SWIGIMPORT inworld_ParagonApiAuthConfig* inworld_ParagonApiAuthConfig_copy(inworld_ParagonApiAuthConfig* carg1);

SWIGIMPORT void inworld_ParagonApiAuthConfig_delete(inworld_ParagonApiAuthConfig* carg1);

SWIGIMPORT void inworld_MCPStdioAuthConfig_set(inworld_MCPStdioAuthConfig* carg1, const char * carg2, const char * carg3);

SWIGIMPORT inworld_MCPStdioAuthConfig* inworld_MCPStdioAuthConfig_new();

SWIGIMPORT inworld_MCPStdioAuthConfig* inworld_MCPStdioAuthConfig_copy(inworld_MCPStdioAuthConfig* carg1);

SWIGIMPORT void inworld_MCPStdioAuthConfig_delete(inworld_MCPStdioAuthConfig* carg1);

SWIGIMPORT void inworld_MCPAuthConfig_set_http_auth_config(inworld_MCPAuthConfig* carg1, inworld_MCPHttpAuthConfig* carg2);

SWIGIMPORT void inworld_MCPAuthConfig_set_stdio_auth_config(inworld_MCPAuthConfig* carg1, inworld_MCPStdioAuthConfig* carg2);

SWIGIMPORT void inworld_MCPAuthConfig_set_paragon_api_auth_config(inworld_MCPAuthConfig* carg1, inworld_ParagonApiAuthConfig* carg2);

SWIGIMPORT inworld_MCPAuthConfig* inworld_MCPAuthConfig_new();

SWIGIMPORT inworld_MCPAuthConfig* inworld_MCPAuthConfig_copy(inworld_MCPAuthConfig* carg1);

SWIGIMPORT void inworld_MCPAuthConfig_delete(inworld_MCPAuthConfig* carg1);

SWIGIMPORT void inworld_MCPSessionCreationConfig_transport_set(inworld_MCPSessionCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MCPSessionCreationConfig_transport_get(inworld_MCPSessionCreationConfig* carg1);

SWIGIMPORT void inworld_MCPSessionCreationConfig_endpoint_set(inworld_MCPSessionCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MCPSessionCreationConfig_endpoint_get(inworld_MCPSessionCreationConfig* carg1);

SWIGIMPORT void inworld_MCPSessionCreationConfig_auth_config_set(inworld_MCPSessionCreationConfig* carg1, inworld_MCPAuthConfig* carg2);

SWIGIMPORT inworld_MCPAuthConfig* inworld_MCPSessionCreationConfig_auth_config_get(inworld_MCPSessionCreationConfig* carg1);

SWIGIMPORT inworld_MCPSessionCreationConfig* inworld_MCPSessionCreationConfig_new();

SWIGIMPORT inworld_MCPSessionCreationConfig* inworld_MCPSessionCreationConfig_copy(inworld_MCPSessionCreationConfig* carg1);

SWIGIMPORT void inworld_MCPSessionCreationConfig_delete(inworld_MCPSessionCreationConfig* carg1);

SWIGIMPORT void inworld_MCPClientCreationConfig_session_config_set(inworld_MCPClientCreationConfig* carg1, inworld_MCPSessionCreationConfig* carg2);

SWIGIMPORT inworld_MCPSessionCreationConfig* inworld_MCPClientCreationConfig_session_config_get(inworld_MCPClientCreationConfig* carg1);

SWIGIMPORT inworld_MCPClientCreationConfig* inworld_MCPClientCreationConfig_new();

SWIGIMPORT inworld_MCPClientCreationConfig* inworld_MCPClientCreationConfig_copy(inworld_MCPClientCreationConfig* carg1);

SWIGIMPORT void inworld_MCPClientCreationConfig_delete(inworld_MCPClientCreationConfig* carg1);

SWIGIMPORT void inworld_MCPClientFactory_delete(inworld_MCPClientFactory* carg1);

SWIGIMPORT inworld_StatusOr_MCPClientInterface* inworld_MCPClientFactory_CreateMCPClient(inworld_MCPClientFactory* carg1, inworld_MCPClientCreationConfig* carg2);

SWIGIMPORT inworld_MCPClientFactory* inworld_MCPClientFactory_new();

SWIGIMPORT inworld_MCPClientFactory* inworld_MCPClientFactory_copy(inworld_MCPClientFactory* carg1);

SWIGIMPORT void inworld_TypedNode_MatchedPhrases_delete(inworld_TypedNode_MatchedPhrases* carg1);

SWIGIMPORT const char * inworld_TypedNode_MatchedPhrases_id(inworld_TypedNode_MatchedPhrases* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_new_rcstd_shared_ptr_Sl_inworld_graphs_EmbeddingMatcherNode_Sg_(inworld_EmbeddingMatcherNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_ok(inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_status(inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* carg1);

SWIGIMPORT inworld_EmbeddingMatcherNode* inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_value(inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_copy(inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_delete(inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedPhrases* inworld_StatusOr_SharedPtr_MatchedPhrases_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedPhrases* inworld_StatusOr_SharedPtr_MatchedPhrases_new_rcstd_shared_ptr_Sl_inworld_graphs_MatchedPhrases_Sg_(inworld_MatchedPhrases* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedPhrases* inworld_StatusOr_SharedPtr_MatchedPhrases_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_MatchedPhrases_ok(inworld_StatusOr_SharedPtr_MatchedPhrases* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_MatchedPhrases_status(inworld_StatusOr_SharedPtr_MatchedPhrases* carg1);

SWIGIMPORT inworld_MatchedPhrases* inworld_StatusOr_SharedPtr_MatchedPhrases_value(inworld_StatusOr_SharedPtr_MatchedPhrases* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedPhrases* inworld_StatusOr_SharedPtr_MatchedPhrases_copy(inworld_StatusOr_SharedPtr_MatchedPhrases* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_MatchedPhrases_delete(inworld_StatusOr_SharedPtr_MatchedPhrases* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherNodeCreationConfig_phrases_set(inworld_EmbeddingMatcherNodeCreationConfig* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_EmbeddingMatcherNodeCreationConfig_phrases_get(inworld_EmbeddingMatcherNodeCreationConfig* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherNodeCreationConfig_embedder_component_id_set(inworld_EmbeddingMatcherNodeCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_EmbeddingMatcherNodeCreationConfig_embedder_component_id_get(inworld_EmbeddingMatcherNodeCreationConfig* carg1);

SWIGIMPORT inworld_EmbeddingMatcherNodeCreationConfig* inworld_EmbeddingMatcherNodeCreationConfig_new();

SWIGIMPORT inworld_EmbeddingMatcherNodeCreationConfig* inworld_EmbeddingMatcherNodeCreationConfig_copy(inworld_EmbeddingMatcherNodeCreationConfig* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherNodeCreationConfig_delete(inworld_EmbeddingMatcherNodeCreationConfig* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherNodeExecutionConfig_similarity_threshold_set(inworld_EmbeddingMatcherNodeExecutionConfig* carg1, float carg2);

SWIGIMPORT float inworld_EmbeddingMatcherNodeExecutionConfig_similarity_threshold_get(inworld_EmbeddingMatcherNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherNodeExecutionConfig_top_n_set(inworld_EmbeddingMatcherNodeExecutionConfig* carg1, size_t carg2);

SWIGIMPORT size_t inworld_EmbeddingMatcherNodeExecutionConfig_top_n_get(inworld_EmbeddingMatcherNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_EmbeddingMatcherNodeExecutionConfig_is_valid(inworld_EmbeddingMatcherNodeExecutionConfig* carg1);

SWIGIMPORT inworld_EmbeddingMatcherNodeExecutionConfig* inworld_EmbeddingMatcherNodeExecutionConfig_new();

SWIGIMPORT inworld_EmbeddingMatcherNodeExecutionConfig* inworld_EmbeddingMatcherNodeExecutionConfig_copy(inworld_EmbeddingMatcherNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherNodeExecutionConfig_delete(inworld_EmbeddingMatcherNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherNodeExecutionConfig_report_to_client_set(inworld_EmbeddingMatcherNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_EmbeddingMatcherNodeExecutionConfig_report_to_client_get(inworld_EmbeddingMatcherNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherNodeExecutionConfig_properties_set(inworld_EmbeddingMatcherNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_EmbeddingMatcherNodeExecutionConfig_properties_get(inworld_EmbeddingMatcherNodeExecutionConfig* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* inworld_EmbeddingMatcherNode_Create(const char * carg1, inworld_CreationContext* carg2, inworld_EmbeddingMatcherNodeCreationConfig* carg3, inworld_EmbeddingMatcherNodeExecutionConfig* carg4);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedPhrases* inworld_EmbeddingMatcherNode_Process(inworld_EmbeddingMatcherNode* carg1, inworld_ProcessContext* carg2, inworld_Text* carg3);

SWIGIMPORT bool inworld_EmbeddingMatcherNode_is_valid(inworld_EmbeddingMatcherNode* carg1);

SWIGIMPORT inworld_EmbeddingMatcherNode* inworld_EmbeddingMatcherNode_copy(inworld_EmbeddingMatcherNode* carg1);

SWIGIMPORT void inworld_EmbeddingMatcherNode_delete(inworld_EmbeddingMatcherNode* carg1);

SWIGIMPORT const char * inworld_EmbeddingMatcherNode_id(inworld_EmbeddingMatcherNode* carg1);

SWIGIMPORT inworld_optional_Condition* inworld_optional_Condition_new();

SWIGIMPORT inworld_optional_Condition* inworld_optional_Condition_new_rcinworld_graphs_Condition(inworld_Condition* carg1);

SWIGIMPORT inworld_optional_Condition* inworld_optional_Condition_copy(inworld_optional_Condition* carg1);

SWIGIMPORT void inworld_optional_Condition_delete(inworld_optional_Condition* carg1);

SWIGIMPORT bool inworld_optional_Condition_has_value(inworld_optional_Condition* carg1);

SWIGIMPORT inworld_Condition* inworld_optional_Condition_value(inworld_optional_Condition* carg1);

SWIGIMPORT inworld_Condition* inworld_optional_Condition_valueConst(inworld_optional_Condition* carg1);

SWIGIMPORT inworld_Condition* inworld_optional_Condition_value_or(inworld_optional_Condition* carg1, inworld_Condition* carg2);

SWIGIMPORT void inworld_optional_Condition_reset(inworld_optional_Condition* carg1);

SWIGIMPORT inworld_Condition* inworld_optional_Condition_get(inworld_optional_Condition* carg1);

SWIGIMPORT inworld_Condition* inworld_optional_Condition_getConst(inworld_optional_Condition* carg1);

SWIGIMPORT inworld_Condition* inworld_optional_Condition_get_value(inworld_optional_Condition* carg1);

SWIGIMPORT void inworld_optional_Condition_set_value(inworld_optional_Condition* carg1, inworld_Condition* carg2);

SWIGIMPORT void inworld_Condition_intents_set(inworld_Condition* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_Condition_intents_get(inworld_Condition* carg1);

SWIGIMPORT void inworld_Condition_detect_set(inworld_Condition* carg1, inworld_optional_string* carg2);

SWIGIMPORT inworld_optional_string* inworld_Condition_detect_get(inworld_Condition* carg1);

SWIGIMPORT void inworld_Condition_required_goals_set(inworld_Condition* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_Condition_required_goals_get(inworld_Condition* carg1);

SWIGIMPORT inworld_Condition* inworld_Condition_new();

SWIGIMPORT inworld_Condition* inworld_Condition_copy(inworld_Condition* carg1);

SWIGIMPORT void inworld_Condition_delete(inworld_Condition* carg1);

SWIGIMPORT void inworld_Goal_name_set(inworld_Goal* carg1, const char * carg2);

SWIGIMPORT const char * inworld_Goal_name_get(inworld_Goal* carg1);

SWIGIMPORT void inworld_Goal_motivation_set(inworld_Goal* carg1, inworld_optional_string* carg2);

SWIGIMPORT inworld_optional_string* inworld_Goal_motivation_get(inworld_Goal* carg1);

SWIGIMPORT void inworld_Goal_repeatable_set(inworld_Goal* carg1, bool carg2);

SWIGIMPORT bool inworld_Goal_repeatable_get(inworld_Goal* carg1);

SWIGIMPORT void inworld_Goal_activation_condition_set(inworld_Goal* carg1, inworld_optional_Condition* carg2);

SWIGIMPORT inworld_optional_Condition* inworld_Goal_activation_condition_get(inworld_Goal* carg1);

SWIGIMPORT void inworld_Goal_completion_condition_set(inworld_Goal* carg1, inworld_optional_Condition* carg2);

SWIGIMPORT inworld_optional_Condition* inworld_Goal_completion_condition_get(inworld_Goal* carg1);

SWIGIMPORT inworld_Goal* inworld_Goal_new();

SWIGIMPORT inworld_Goal* inworld_Goal_copy(inworld_Goal* carg1);

SWIGIMPORT void inworld_Goal_delete(inworld_Goal* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_GoalAdvancementNode* inworld_StatusOr_SharedPtr_GoalAdvancementNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_GoalAdvancementNode* inworld_StatusOr_SharedPtr_GoalAdvancementNode_new_rcstd_shared_ptr_Sl_inworld_graphs_GoalAdvancementNode_Sg_(inworld_GoalAdvancementNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_GoalAdvancementNode* inworld_StatusOr_SharedPtr_GoalAdvancementNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_GoalAdvancementNode_ok(inworld_StatusOr_SharedPtr_GoalAdvancementNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_GoalAdvancementNode_status(inworld_StatusOr_SharedPtr_GoalAdvancementNode* carg1);

SWIGIMPORT inworld_GoalAdvancementNode* inworld_StatusOr_SharedPtr_GoalAdvancementNode_value(inworld_StatusOr_SharedPtr_GoalAdvancementNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_GoalAdvancementNode* inworld_StatusOr_SharedPtr_GoalAdvancementNode_copy(inworld_StatusOr_SharedPtr_GoalAdvancementNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_GoalAdvancementNode_delete(inworld_StatusOr_SharedPtr_GoalAdvancementNode* carg1);

SWIGIMPORT inworld_vector_Goal* inworld_vector_Goal_new();

SWIGIMPORT inworld_vector_Goal* inworld_vector_Goal_copy(inworld_vector_Goal* carg1);

SWIGIMPORT size_t inworld_vector_Goal_size(inworld_vector_Goal* carg1);

SWIGIMPORT size_t inworld_vector_Goal_capacity(inworld_vector_Goal* carg1);

SWIGIMPORT void inworld_vector_Goal_reserve(inworld_vector_Goal* carg1, size_t carg2);

SWIGIMPORT bool inworld_vector_Goal_empty(inworld_vector_Goal* carg1);

SWIGIMPORT void inworld_vector_Goal_clear(inworld_vector_Goal* carg1);

SWIGIMPORT void inworld_vector_Goal_push_back(inworld_vector_Goal* carg1, inworld_Goal* carg2);

SWIGIMPORT inworld_Goal* inworld_vector_Goal_get(inworld_vector_Goal* carg1, int carg2);

SWIGIMPORT void inworld_vector_Goal_set(inworld_vector_Goal* carg1, int carg2, inworld_Goal* carg3);

SWIGIMPORT void inworld_vector_Goal_delete(inworld_vector_Goal* carg1);

SWIGIMPORT void inworld_GoalAdvancementNodeCreationConfig_goals_set(inworld_GoalAdvancementNodeCreationConfig* carg1, inworld_vector_Goal* carg2);

SWIGIMPORT inworld_vector_Goal* inworld_GoalAdvancementNodeCreationConfig_goals_get(inworld_GoalAdvancementNodeCreationConfig* carg1);

SWIGIMPORT inworld_GoalAdvancementNodeCreationConfig* inworld_GoalAdvancementNodeCreationConfig_new();

SWIGIMPORT inworld_GoalAdvancementNodeCreationConfig* inworld_GoalAdvancementNodeCreationConfig_copy(inworld_GoalAdvancementNodeCreationConfig* carg1);

SWIGIMPORT void inworld_GoalAdvancementNodeCreationConfig_delete(inworld_GoalAdvancementNodeCreationConfig* carg1);

SWIGIMPORT void inworld_GoalAdvancementNodeExecutionConfig_llm_component_id_set(inworld_GoalAdvancementNodeExecutionConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_GoalAdvancementNodeExecutionConfig_llm_component_id_get(inworld_GoalAdvancementNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_GoalAdvancementNodeExecutionConfig_text_generation_config_set(inworld_GoalAdvancementNodeExecutionConfig* carg1, inworld_optional_TextGenerationConfig* carg2);

SWIGIMPORT inworld_optional_TextGenerationConfig* inworld_GoalAdvancementNodeExecutionConfig_text_generation_config_get(inworld_GoalAdvancementNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_GoalAdvancementNodeExecutionConfig_is_valid(inworld_GoalAdvancementNodeExecutionConfig* carg1);

SWIGIMPORT inworld_GoalAdvancementNodeExecutionConfig* inworld_GoalAdvancementNodeExecutionConfig_new();

SWIGIMPORT inworld_GoalAdvancementNodeExecutionConfig* inworld_GoalAdvancementNodeExecutionConfig_copy(inworld_GoalAdvancementNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_GoalAdvancementNodeExecutionConfig_delete(inworld_GoalAdvancementNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_GoalAdvancementNodeExecutionConfig_report_to_client_set(inworld_GoalAdvancementNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_GoalAdvancementNodeExecutionConfig_report_to_client_get(inworld_GoalAdvancementNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_GoalAdvancementNodeExecutionConfig_properties_set(inworld_GoalAdvancementNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_GoalAdvancementNodeExecutionConfig_properties_get(inworld_GoalAdvancementNodeExecutionConfig* carg1);

SWIGIMPORT SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__GoalAdvancement_t_t* inworld_GoalAdvancementNode_Process(inworld_GoalAdvancementNode* carg1, inworld_ProcessContext* carg2, inworld_EventHistory* carg3, inworld_Json* carg4, inworld_Text* carg5, inworld_Text* carg6, inworld_Text* carg7, inworld_Text* carg8, inworld_Text* carg9, SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__MatchedIntents_inworld__graphs__Text_t_t* carg10, SWIGTYPE_std__shared_ptrT_std__optionalT_inworld__graphs__Text_t_t* carg11);

SWIGIMPORT bool inworld_GoalAdvancementNode_is_valid(inworld_GoalAdvancementNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_GoalAdvancementNode* inworld_GoalAdvancementNode_Create(const char * carg1, inworld_GoalAdvancementNodeCreationConfig* carg2, inworld_GoalAdvancementNodeExecutionConfig* carg3);

SWIGIMPORT void inworld_GoalAdvancementNode_delete(inworld_GoalAdvancementNode* carg1);

SWIGIMPORT const char * inworld_GoalAdvancementNode_id(inworld_GoalAdvancementNode* carg1);

SWIGIMPORT void inworld_TypedNode_MatchedIntents_delete(inworld_TypedNode_MatchedIntents* carg1);

SWIGIMPORT const char * inworld_TypedNode_MatchedIntents_id(inworld_TypedNode_MatchedIntents* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_IntentNode* inworld_StatusOr_SharedPtr_IntentNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_IntentNode* inworld_StatusOr_SharedPtr_IntentNode_new_rcstd_shared_ptr_Sl_inworld_graphs_IntentNode_Sg_(inworld_IntentNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_IntentNode* inworld_StatusOr_SharedPtr_IntentNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_IntentNode_ok(inworld_StatusOr_SharedPtr_IntentNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_IntentNode_status(inworld_StatusOr_SharedPtr_IntentNode* carg1);

SWIGIMPORT inworld_IntentNode* inworld_StatusOr_SharedPtr_IntentNode_value(inworld_StatusOr_SharedPtr_IntentNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_IntentNode* inworld_StatusOr_SharedPtr_IntentNode_copy(inworld_StatusOr_SharedPtr_IntentNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_IntentNode_delete(inworld_StatusOr_SharedPtr_IntentNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedIntents* inworld_StatusOr_SharedPtr_MatchedIntents_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedIntents* inworld_StatusOr_SharedPtr_MatchedIntents_new_rcstd_shared_ptr_Sl_inworld_graphs_MatchedIntents_Sg_(inworld_MatchedIntents* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedIntents* inworld_StatusOr_SharedPtr_MatchedIntents_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_MatchedIntents_ok(inworld_StatusOr_SharedPtr_MatchedIntents* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_MatchedIntents_status(inworld_StatusOr_SharedPtr_MatchedIntents* carg1);

SWIGIMPORT inworld_MatchedIntents* inworld_StatusOr_SharedPtr_MatchedIntents_value(inworld_StatusOr_SharedPtr_MatchedIntents* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedIntents* inworld_StatusOr_SharedPtr_MatchedIntents_copy(inworld_StatusOr_SharedPtr_MatchedIntents* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_MatchedIntents_delete(inworld_StatusOr_SharedPtr_MatchedIntents* carg1);

SWIGIMPORT inworld_optional_TextEmbedderCreationConfig* inworld_optional_TextEmbedderCreationConfig_new();

SWIGIMPORT inworld_optional_TextEmbedderCreationConfig* inworld_optional_TextEmbedderCreationConfig_new_rcinworld_TextEmbedderCreationConfig(inworld_TextEmbedderCreationConfig* carg1);

SWIGIMPORT inworld_optional_TextEmbedderCreationConfig* inworld_optional_TextEmbedderCreationConfig_copy(inworld_optional_TextEmbedderCreationConfig* carg1);

SWIGIMPORT void inworld_optional_TextEmbedderCreationConfig_delete(inworld_optional_TextEmbedderCreationConfig* carg1);

SWIGIMPORT bool inworld_optional_TextEmbedderCreationConfig_has_value(inworld_optional_TextEmbedderCreationConfig* carg1);

SWIGIMPORT inworld_TextEmbedderCreationConfig* inworld_optional_TextEmbedderCreationConfig_value(inworld_optional_TextEmbedderCreationConfig* carg1);

SWIGIMPORT inworld_TextEmbedderCreationConfig* inworld_optional_TextEmbedderCreationConfig_valueConst(inworld_optional_TextEmbedderCreationConfig* carg1);

SWIGIMPORT inworld_TextEmbedderCreationConfig* inworld_optional_TextEmbedderCreationConfig_value_or(inworld_optional_TextEmbedderCreationConfig* carg1, inworld_TextEmbedderCreationConfig* carg2);

SWIGIMPORT void inworld_optional_TextEmbedderCreationConfig_reset(inworld_optional_TextEmbedderCreationConfig* carg1);

SWIGIMPORT inworld_TextEmbedderCreationConfig* inworld_optional_TextEmbedderCreationConfig_get(inworld_optional_TextEmbedderCreationConfig* carg1);

SWIGIMPORT inworld_TextEmbedderCreationConfig* inworld_optional_TextEmbedderCreationConfig_getConst(inworld_optional_TextEmbedderCreationConfig* carg1);

SWIGIMPORT inworld_TextEmbedderCreationConfig* inworld_optional_TextEmbedderCreationConfig_get_value(inworld_optional_TextEmbedderCreationConfig* carg1);

SWIGIMPORT void inworld_optional_TextEmbedderCreationConfig_set_value(inworld_optional_TextEmbedderCreationConfig* carg1, inworld_TextEmbedderCreationConfig* carg2);

SWIGIMPORT inworld_optional_LLMCreationConfig* inworld_optional_LLMCreationConfig_new();

SWIGIMPORT inworld_optional_LLMCreationConfig* inworld_optional_LLMCreationConfig_new_rcinworld_LLMCreationConfig(inworld_LLMCreationConfig* carg1);

SWIGIMPORT inworld_optional_LLMCreationConfig* inworld_optional_LLMCreationConfig_copy(inworld_optional_LLMCreationConfig* carg1);

SWIGIMPORT void inworld_optional_LLMCreationConfig_delete(inworld_optional_LLMCreationConfig* carg1);

SWIGIMPORT bool inworld_optional_LLMCreationConfig_has_value(inworld_optional_LLMCreationConfig* carg1);

SWIGIMPORT inworld_LLMCreationConfig* inworld_optional_LLMCreationConfig_value(inworld_optional_LLMCreationConfig* carg1);

SWIGIMPORT inworld_LLMCreationConfig* inworld_optional_LLMCreationConfig_valueConst(inworld_optional_LLMCreationConfig* carg1);

SWIGIMPORT inworld_LLMCreationConfig* inworld_optional_LLMCreationConfig_value_or(inworld_optional_LLMCreationConfig* carg1, inworld_LLMCreationConfig* carg2);

SWIGIMPORT void inworld_optional_LLMCreationConfig_reset(inworld_optional_LLMCreationConfig* carg1);

SWIGIMPORT inworld_LLMCreationConfig* inworld_optional_LLMCreationConfig_get(inworld_optional_LLMCreationConfig* carg1);

SWIGIMPORT inworld_LLMCreationConfig* inworld_optional_LLMCreationConfig_getConst(inworld_optional_LLMCreationConfig* carg1);

SWIGIMPORT inworld_LLMCreationConfig* inworld_optional_LLMCreationConfig_get_value(inworld_optional_LLMCreationConfig* carg1);

SWIGIMPORT void inworld_optional_LLMCreationConfig_set_value(inworld_optional_LLMCreationConfig* carg1, inworld_LLMCreationConfig* carg2);

SWIGIMPORT void inworld_IntentNodeExecutionConfig_matcher_config_set(inworld_IntentNodeExecutionConfig* carg1, inworld_IntentMatcherConfig* carg2);

SWIGIMPORT inworld_IntentMatcherConfig* inworld_IntentNodeExecutionConfig_matcher_config_get(inworld_IntentNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_IntentNodeExecutionConfig_is_valid(inworld_IntentNodeExecutionConfig* carg1);

SWIGIMPORT inworld_IntentNodeExecutionConfig* inworld_IntentNodeExecutionConfig_new();

SWIGIMPORT inworld_IntentNodeExecutionConfig* inworld_IntentNodeExecutionConfig_copy(inworld_IntentNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_IntentNodeExecutionConfig_delete(inworld_IntentNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_IntentNodeExecutionConfig_report_to_client_set(inworld_IntentNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_IntentNodeExecutionConfig_report_to_client_get(inworld_IntentNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_IntentNodeExecutionConfig_properties_set(inworld_IntentNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_IntentNodeExecutionConfig_properties_get(inworld_IntentNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_IntentNodeCreationConfig_intents_set(inworld_IntentNodeCreationConfig* carg1, inworld_vector_Intent* carg2);

SWIGIMPORT inworld_vector_Intent* inworld_IntentNodeCreationConfig_intents_get(inworld_IntentNodeCreationConfig* carg1);

SWIGIMPORT void inworld_IntentNodeCreationConfig_embedder_component_id_set(inworld_IntentNodeCreationConfig* carg1, inworld_optional_string* carg2);

SWIGIMPORT inworld_optional_string* inworld_IntentNodeCreationConfig_embedder_component_id_get(inworld_IntentNodeCreationConfig* carg1);

SWIGIMPORT void inworld_IntentNodeCreationConfig_llm_component_id_set(inworld_IntentNodeCreationConfig* carg1, inworld_optional_string* carg2);

SWIGIMPORT inworld_optional_string* inworld_IntentNodeCreationConfig_llm_component_id_get(inworld_IntentNodeCreationConfig* carg1);

SWIGIMPORT inworld_IntentNodeCreationConfig* inworld_IntentNodeCreationConfig_new();

SWIGIMPORT inworld_IntentNodeCreationConfig* inworld_IntentNodeCreationConfig_copy(inworld_IntentNodeCreationConfig* carg1);

SWIGIMPORT void inworld_IntentNodeCreationConfig_delete(inworld_IntentNodeCreationConfig* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedIntents* inworld_IntentNode_Process(inworld_IntentNode* carg1, inworld_ProcessContext* carg2, inworld_Text* carg3);

SWIGIMPORT bool inworld_IntentNode_is_valid(inworld_IntentNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_IntentNode* inworld_IntentNode_Create(const char * carg1, inworld_CreationContext* carg2, inworld_IntentNodeCreationConfig* carg3, inworld_IntentNodeExecutionConfig* carg4);

SWIGIMPORT void inworld_IntentNode_delete(inworld_IntentNode* carg1);

SWIGIMPORT const char * inworld_IntentNode_id(inworld_IntentNode* carg1);

SWIGIMPORT void inworld_TypedNode_MatchedKeywords_delete(inworld_TypedNode_MatchedKeywords* carg1);

SWIGIMPORT const char * inworld_TypedNode_MatchedKeywords_id(inworld_TypedNode_MatchedKeywords* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KeywordMatcherNode* inworld_StatusOr_SharedPtr_KeywordMatcherNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_KeywordMatcherNode* inworld_StatusOr_SharedPtr_KeywordMatcherNode_new_rcstd_shared_ptr_Sl_inworld_graphs_KeywordMatcherNode_Sg_(inworld_KeywordMatcherNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KeywordMatcherNode* inworld_StatusOr_SharedPtr_KeywordMatcherNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_KeywordMatcherNode_ok(inworld_StatusOr_SharedPtr_KeywordMatcherNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_KeywordMatcherNode_status(inworld_StatusOr_SharedPtr_KeywordMatcherNode* carg1);

SWIGIMPORT inworld_KeywordMatcherNode* inworld_StatusOr_SharedPtr_KeywordMatcherNode_value(inworld_StatusOr_SharedPtr_KeywordMatcherNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KeywordMatcherNode* inworld_StatusOr_SharedPtr_KeywordMatcherNode_copy(inworld_StatusOr_SharedPtr_KeywordMatcherNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_KeywordMatcherNode_delete(inworld_StatusOr_SharedPtr_KeywordMatcherNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedKeywords* inworld_StatusOr_SharedPtr_MatchedKeywords_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedKeywords* inworld_StatusOr_SharedPtr_MatchedKeywords_new_rcstd_shared_ptr_Sl_inworld_graphs_MatchedKeywords_Sg_(inworld_MatchedKeywords* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedKeywords* inworld_StatusOr_SharedPtr_MatchedKeywords_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_MatchedKeywords_ok(inworld_StatusOr_SharedPtr_MatchedKeywords* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_MatchedKeywords_status(inworld_StatusOr_SharedPtr_MatchedKeywords* carg1);

SWIGIMPORT inworld_MatchedKeywords* inworld_StatusOr_SharedPtr_MatchedKeywords_value(inworld_StatusOr_SharedPtr_MatchedKeywords* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedKeywords* inworld_StatusOr_SharedPtr_MatchedKeywords_copy(inworld_StatusOr_SharedPtr_MatchedKeywords* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_MatchedKeywords_delete(inworld_StatusOr_SharedPtr_MatchedKeywords* carg1);

SWIGIMPORT void inworld_KeywordMatcherNodeCreationConfig_keyword_groups_set(inworld_KeywordMatcherNodeCreationConfig* carg1, inworld_vector_KeywordGroup* carg2);

SWIGIMPORT inworld_vector_KeywordGroup* inworld_KeywordMatcherNodeCreationConfig_keyword_groups_get(inworld_KeywordMatcherNodeCreationConfig* carg1);

SWIGIMPORT inworld_KeywordMatcherNodeCreationConfig* inworld_KeywordMatcherNodeCreationConfig_new();

SWIGIMPORT inworld_KeywordMatcherNodeCreationConfig* inworld_KeywordMatcherNodeCreationConfig_copy(inworld_KeywordMatcherNodeCreationConfig* carg1);

SWIGIMPORT void inworld_KeywordMatcherNodeCreationConfig_delete(inworld_KeywordMatcherNodeCreationConfig* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MatchedKeywords* inworld_KeywordMatcherNode_Process(inworld_KeywordMatcherNode* carg1, inworld_ProcessContext* carg2, inworld_Text* carg3);

SWIGIMPORT bool inworld_KeywordMatcherNode_is_valid(inworld_KeywordMatcherNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KeywordMatcherNode* inworld_KeywordMatcherNode_Create_rcstd_string_rcinworld_graphs_KeywordMatcherNodeCreationConfig(const char * carg1, inworld_KeywordMatcherNodeCreationConfig* carg2);

SWIGIMPORT inworld_StatusOr_SharedPtr_KeywordMatcherNode* inworld_KeywordMatcherNode_Create_rcstd_string_rcinworld_graphs_KeywordMatcherNodeCreationConfig_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg_(const char * carg1, inworld_KeywordMatcherNodeCreationConfig* carg2, inworld_NodeExecutionConfig* carg3);

SWIGIMPORT inworld_KeywordMatcherNode* inworld_KeywordMatcherNode_copy(inworld_KeywordMatcherNode* carg1);

SWIGIMPORT void inworld_KeywordMatcherNode_delete(inworld_KeywordMatcherNode* carg1);

SWIGIMPORT const char * inworld_KeywordMatcherNode_id(inworld_KeywordMatcherNode* carg1);

SWIGIMPORT void inworld_TypedNode_KnowledgeRecords_Text_Text_delete(inworld_TypedNode_KnowledgeRecords_Text_Text* carg1);

SWIGIMPORT const char * inworld_TypedNode_KnowledgeRecords_Text_Text_id(inworld_TypedNode_KnowledgeRecords_Text_Text* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeNode* inworld_StatusOr_SharedPtr_KnowledgeNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeNode* inworld_StatusOr_SharedPtr_KnowledgeNode_new_rcstd_shared_ptr_Sl_inworld_graphs_KnowledgeNode_Sg_(inworld_KnowledgeNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeNode* inworld_StatusOr_SharedPtr_KnowledgeNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_KnowledgeNode_ok(inworld_StatusOr_SharedPtr_KnowledgeNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_KnowledgeNode_status(inworld_StatusOr_SharedPtr_KnowledgeNode* carg1);

SWIGIMPORT inworld_KnowledgeNode* inworld_StatusOr_SharedPtr_KnowledgeNode_value(inworld_StatusOr_SharedPtr_KnowledgeNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeNode* inworld_StatusOr_SharedPtr_KnowledgeNode_copy(inworld_StatusOr_SharedPtr_KnowledgeNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_KnowledgeNode_delete(inworld_StatusOr_SharedPtr_KnowledgeNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeRecords* inworld_StatusOr_SharedPtr_KnowledgeRecords_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeRecords* inworld_StatusOr_SharedPtr_KnowledgeRecords_new_rcstd_shared_ptr_Sl_inworld_graphs_KnowledgeRecords_Sg_(inworld_KnowledgeRecords* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeRecords* inworld_StatusOr_SharedPtr_KnowledgeRecords_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_KnowledgeRecords_ok(inworld_StatusOr_SharedPtr_KnowledgeRecords* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_KnowledgeRecords_status(inworld_StatusOr_SharedPtr_KnowledgeRecords* carg1);

SWIGIMPORT inworld_KnowledgeRecords* inworld_StatusOr_SharedPtr_KnowledgeRecords_value(inworld_StatusOr_SharedPtr_KnowledgeRecords* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeRecords* inworld_StatusOr_SharedPtr_KnowledgeRecords_copy(inworld_StatusOr_SharedPtr_KnowledgeRecords* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_KnowledgeRecords_delete(inworld_StatusOr_SharedPtr_KnowledgeRecords* carg1);

SWIGIMPORT void inworld_KnowledgeNodeCreationConfig_knowledge_id_set(inworld_KnowledgeNodeCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_KnowledgeNodeCreationConfig_knowledge_id_get(inworld_KnowledgeNodeCreationConfig* carg1);

SWIGIMPORT void inworld_KnowledgeNodeCreationConfig_knowledge_records_set(inworld_KnowledgeNodeCreationConfig* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_KnowledgeNodeCreationConfig_knowledge_records_get(inworld_KnowledgeNodeCreationConfig* carg1);

SWIGIMPORT void inworld_KnowledgeNodeCreationConfig_knowledge_component_id_set(inworld_KnowledgeNodeCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_KnowledgeNodeCreationConfig_knowledge_component_id_get(inworld_KnowledgeNodeCreationConfig* carg1);

SWIGIMPORT inworld_KnowledgeNodeCreationConfig* inworld_KnowledgeNodeCreationConfig_new();

SWIGIMPORT inworld_KnowledgeNodeCreationConfig* inworld_KnowledgeNodeCreationConfig_copy(inworld_KnowledgeNodeCreationConfig* carg1);

SWIGIMPORT void inworld_KnowledgeNodeCreationConfig_delete(inworld_KnowledgeNodeCreationConfig* carg1);

SWIGIMPORT void inworld_KnowledgeNodeExecutionConfig_knowledge_ids_set(inworld_KnowledgeNodeExecutionConfig* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_KnowledgeNodeExecutionConfig_knowledge_ids_get(inworld_KnowledgeNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_KnowledgeNodeExecutionConfig_retrieval_config_set(inworld_KnowledgeNodeExecutionConfig* carg1, inworld_RetrievalConfig* carg2);

SWIGIMPORT inworld_RetrievalConfig* inworld_KnowledgeNodeExecutionConfig_retrieval_config_get(inworld_KnowledgeNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_KnowledgeNodeExecutionConfig_is_valid(inworld_KnowledgeNodeExecutionConfig* carg1);

SWIGIMPORT inworld_KnowledgeNodeExecutionConfig* inworld_KnowledgeNodeExecutionConfig_new();

SWIGIMPORT inworld_KnowledgeNodeExecutionConfig* inworld_KnowledgeNodeExecutionConfig_copy(inworld_KnowledgeNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_KnowledgeNodeExecutionConfig_delete(inworld_KnowledgeNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_KnowledgeNodeExecutionConfig_report_to_client_set(inworld_KnowledgeNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_KnowledgeNodeExecutionConfig_report_to_client_get(inworld_KnowledgeNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_KnowledgeNodeExecutionConfig_properties_set(inworld_KnowledgeNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_KnowledgeNodeExecutionConfig_properties_get(inworld_KnowledgeNodeExecutionConfig* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeRecords* inworld_KnowledgeNode_Process(inworld_KnowledgeNode* carg1, inworld_ProcessContext* carg2, inworld_Text* carg3);

SWIGIMPORT bool inworld_KnowledgeNode_is_valid(inworld_KnowledgeNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeNode* inworld_KnowledgeNode_Create(const char * carg1, inworld_CreationContext* carg2, inworld_KnowledgeNodeCreationConfig* carg3, inworld_KnowledgeNodeExecutionConfig* carg4);

SWIGIMPORT inworld_KnowledgeNode* inworld_KnowledgeNode_copy(inworld_KnowledgeNode* carg1);

SWIGIMPORT void inworld_KnowledgeNode_delete(inworld_KnowledgeNode* carg1);

SWIGIMPORT const char * inworld_KnowledgeNode_id(inworld_KnowledgeNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMChatNode* inworld_StatusOr_SharedPtr_LLMChatNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMChatNode* inworld_StatusOr_SharedPtr_LLMChatNode_new_rcstd_shared_ptr_Sl_inworld_graphs_LLMChatNode_Sg_(inworld_LLMChatNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMChatNode* inworld_StatusOr_SharedPtr_LLMChatNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_LLMChatNode_ok(inworld_StatusOr_SharedPtr_LLMChatNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_LLMChatNode_status(inworld_StatusOr_SharedPtr_LLMChatNode* carg1);

SWIGIMPORT inworld_LLMChatNode* inworld_StatusOr_SharedPtr_LLMChatNode_value(inworld_StatusOr_SharedPtr_LLMChatNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMChatNode* inworld_StatusOr_SharedPtr_LLMChatNode_copy(inworld_StatusOr_SharedPtr_LLMChatNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_LLMChatNode_delete(inworld_StatusOr_SharedPtr_LLMChatNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMChatResponse* inworld_StatusOr_SharedPtr_LLMChatResponse_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMChatResponse* inworld_StatusOr_SharedPtr_LLMChatResponse_new_rcstd_shared_ptr_Sl_inworld_graphs_LLMChatResponse_Sg_(inworld_LLMChatResponse* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMChatResponse* inworld_StatusOr_SharedPtr_LLMChatResponse_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_LLMChatResponse_ok(inworld_StatusOr_SharedPtr_LLMChatResponse* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_LLMChatResponse_status(inworld_StatusOr_SharedPtr_LLMChatResponse* carg1);

SWIGIMPORT inworld_LLMChatResponse* inworld_StatusOr_SharedPtr_LLMChatResponse_value(inworld_StatusOr_SharedPtr_LLMChatResponse* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMChatResponse* inworld_StatusOr_SharedPtr_LLMChatResponse_copy(inworld_StatusOr_SharedPtr_LLMChatResponse* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_LLMChatResponse_delete(inworld_StatusOr_SharedPtr_LLMChatResponse* carg1);

SWIGIMPORT inworld_optional_vector_LLMRoutingConfig* inworld_optional_vector_LLMRoutingConfig_new();

SWIGIMPORT inworld_optional_vector_LLMRoutingConfig* inworld_optional_vector_LLMRoutingConfig_new_rcstd_vector_Sl_inworld_LLMRoutingConfig_Sg_(inworld_vector_LLMRoutingConfig* carg1);

SWIGIMPORT inworld_optional_vector_LLMRoutingConfig* inworld_optional_vector_LLMRoutingConfig_copy(inworld_optional_vector_LLMRoutingConfig* carg1);

SWIGIMPORT void inworld_optional_vector_LLMRoutingConfig_delete(inworld_optional_vector_LLMRoutingConfig* carg1);

SWIGIMPORT bool inworld_optional_vector_LLMRoutingConfig_has_value(inworld_optional_vector_LLMRoutingConfig* carg1);

SWIGIMPORT inworld_vector_LLMRoutingConfig* inworld_optional_vector_LLMRoutingConfig_value(inworld_optional_vector_LLMRoutingConfig* carg1);

SWIGIMPORT inworld_vector_LLMRoutingConfig* inworld_optional_vector_LLMRoutingConfig_valueConst(inworld_optional_vector_LLMRoutingConfig* carg1);

SWIGIMPORT inworld_vector_LLMRoutingConfig* inworld_optional_vector_LLMRoutingConfig_value_or(inworld_optional_vector_LLMRoutingConfig* carg1, inworld_vector_LLMRoutingConfig* carg2);

SWIGIMPORT void inworld_optional_vector_LLMRoutingConfig_reset(inworld_optional_vector_LLMRoutingConfig* carg1);

SWIGIMPORT inworld_vector_LLMRoutingConfig* inworld_optional_vector_LLMRoutingConfig_get(inworld_optional_vector_LLMRoutingConfig* carg1);

SWIGIMPORT inworld_vector_LLMRoutingConfig* inworld_optional_vector_LLMRoutingConfig_getConst(inworld_optional_vector_LLMRoutingConfig* carg1);

SWIGIMPORT inworld_vector_LLMRoutingConfig* inworld_optional_vector_LLMRoutingConfig_get_value(inworld_optional_vector_LLMRoutingConfig* carg1);

SWIGIMPORT void inworld_optional_vector_LLMRoutingConfig_set_value(inworld_optional_vector_LLMRoutingConfig* carg1, inworld_vector_LLMRoutingConfig* carg2);

SWIGIMPORT void inworld_TypedNode_LLMChatResponse_VariantInput_delete(inworld_TypedNode_LLMChatResponse_VariantInput* carg1);

SWIGIMPORT const char * inworld_TypedNode_LLMChatResponse_VariantInput_id(inworld_TypedNode_LLMChatResponse_VariantInput* carg1);

SWIGIMPORT void inworld_StringTemplate_value_set(inworld_StringTemplate* carg1, const char * carg2);

SWIGIMPORT const char * inworld_StringTemplate_value_get(inworld_StringTemplate* carg1);

SWIGIMPORT inworld_StringTemplate* inworld_StringTemplate_new();

SWIGIMPORT inworld_StringTemplate* inworld_StringTemplate_copy(inworld_StringTemplate* carg1);

SWIGIMPORT void inworld_StringTemplate_delete(inworld_StringTemplate* carg1);

SWIGIMPORT inworld_TextContent* inworld_TextContent_new();

SWIGIMPORT inworld_TextContent* inworld_TextContent_copy(inworld_TextContent* carg1);

SWIGIMPORT void inworld_TextContent_delete(inworld_TextContent* carg1);

SWIGIMPORT void inworld_ImageContent_detail_set(inworld_ImageContent* carg1, const char * carg2);

SWIGIMPORT const char * inworld_ImageContent_detail_get(inworld_ImageContent* carg1);

SWIGIMPORT inworld_ImageContent* inworld_ImageContent_new();

SWIGIMPORT inworld_ImageContent* inworld_ImageContent_copy(inworld_ImageContent* carg1);

SWIGIMPORT void inworld_ImageContent_delete(inworld_ImageContent* carg1);

SWIGIMPORT inworld_ChatMessageContent* inworld_ChatMessageContent_new();

SWIGIMPORT inworld_ChatMessageContent* inworld_ChatMessageContent_copy(inworld_ChatMessageContent* carg1);

SWIGIMPORT void inworld_ChatMessageContent_delete(inworld_ChatMessageContent* carg1);

SWIGIMPORT void inworld_ChatMessage_role_set(inworld_ChatMessage* carg1, const char * carg2);

SWIGIMPORT const char * inworld_ChatMessage_role_get(inworld_ChatMessage* carg1);

SWIGIMPORT bool inworld_ChatMessage_HasSingleContent(inworld_ChatMessage* carg1);

SWIGIMPORT bool inworld_ChatMessage_HasMultimodalContent(inworld_ChatMessage* carg1);

SWIGIMPORT void inworld_ChatMessage_SetTextContent(inworld_ChatMessage* carg1, const char * carg2);

SWIGIMPORT void inworld_ChatMessage_SetTemplateContent(inworld_ChatMessage* carg1, const char * carg2);

SWIGIMPORT void inworld_ChatMessage_InitMultimodalContent(inworld_ChatMessage* carg1);

SWIGIMPORT void inworld_ChatMessage_AddTextToMultimodal(inworld_ChatMessage* carg1, const char * carg2);

SWIGIMPORT void inworld_ChatMessage_AddTemplateToMultimodal(inworld_ChatMessage* carg1, const char * carg2);

SWIGIMPORT void inworld_ChatMessage_AddImageToMultimodal_rcstd_string_rcstd_string(inworld_ChatMessage* carg1, const char * carg2, const char * carg3);

SWIGIMPORT void inworld_ChatMessage_AddImageToMultimodal_rcstd_string(inworld_ChatMessage* carg1, const char * carg2);

SWIGIMPORT void inworld_ChatMessage_AddImageTemplateToMultimodal_rcstd_string_rcstd_string(inworld_ChatMessage* carg1, const char * carg2, const char * carg3);

SWIGIMPORT void inworld_ChatMessage_AddImageTemplateToMultimodal_rcstd_string(inworld_ChatMessage* carg1, const char * carg2);

SWIGIMPORT int inworld_ChatMessage_GetMultimodalItemCount(inworld_ChatMessage* carg1);

SWIGIMPORT inworld_ChatMessage* inworld_ChatMessage_new();

SWIGIMPORT inworld_ChatMessage* inworld_ChatMessage_copy(inworld_ChatMessage* carg1);

SWIGIMPORT void inworld_ChatMessage_delete(inworld_ChatMessage* carg1);

SWIGIMPORT void inworld_LLMChatNodeExecutionConfig_llm_component_id_set(inworld_LLMChatNodeExecutionConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LLMChatNodeExecutionConfig_llm_component_id_get(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMChatNodeExecutionConfig_text_generation_config_set(inworld_LLMChatNodeExecutionConfig* carg1, inworld_optional_TextGenerationConfig* carg2);

SWIGIMPORT inworld_optional_TextGenerationConfig* inworld_LLMChatNodeExecutionConfig_text_generation_config_get(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMChatNodeExecutionConfig_message_templates_set(inworld_LLMChatNodeExecutionConfig* carg1, inworld_optional_vector_ChatMessage* carg2);

SWIGIMPORT inworld_optional_vector_ChatMessage* inworld_LLMChatNodeExecutionConfig_message_templates_get(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMChatNodeExecutionConfig_tools_set(inworld_LLMChatNodeExecutionConfig* carg1, inworld_optional_vector_Tool* carg2);

SWIGIMPORT inworld_optional_vector_Tool* inworld_LLMChatNodeExecutionConfig_tools_get(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMChatNodeExecutionConfig_tool_choice_set(inworld_LLMChatNodeExecutionConfig* carg1, inworld_optional_ToolChoice* carg2);

SWIGIMPORT inworld_optional_ToolChoice* inworld_LLMChatNodeExecutionConfig_tool_choice_get(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMChatNodeExecutionConfig_stream_set(inworld_LLMChatNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_LLMChatNodeExecutionConfig_stream_get(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMChatNodeExecutionConfig_response_format_set(inworld_LLMChatNodeExecutionConfig* carg1, enum inworld_ResponseFormat carg2);

SWIGIMPORT enum inworld_ResponseFormat inworld_LLMChatNodeExecutionConfig_response_format_get(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_LLMChatNodeExecutionConfig_is_valid(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT inworld_LLMChatNodeExecutionConfig* inworld_LLMChatNodeExecutionConfig_new();

SWIGIMPORT inworld_LLMChatNodeExecutionConfig* inworld_LLMChatNodeExecutionConfig_copy(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMChatNodeExecutionConfig_delete(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMChatNodeExecutionConfig_report_to_client_set(inworld_LLMChatNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_LLMChatNodeExecutionConfig_report_to_client_get(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMChatNodeExecutionConfig_properties_set(inworld_LLMChatNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_LLMChatNodeExecutionConfig_properties_get(inworld_LLMChatNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_LLMChatNode_is_valid(inworld_LLMChatNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMChatNode* inworld_LLMChatNode_Create(const char * carg1, inworld_LLMChatNodeExecutionConfig* carg2);

SWIGIMPORT void inworld_LLMChatNode_delete(inworld_LLMChatNode* carg1);

SWIGIMPORT const char * inworld_LLMChatNode_id(inworld_LLMChatNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionNode* inworld_StatusOr_SharedPtr_LLMCompletionNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionNode* inworld_StatusOr_SharedPtr_LLMCompletionNode_new_rcstd_shared_ptr_Sl_inworld_graphs_LLMCompletionNode_Sg_(inworld_LLMCompletionNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionNode* inworld_StatusOr_SharedPtr_LLMCompletionNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_LLMCompletionNode_ok(inworld_StatusOr_SharedPtr_LLMCompletionNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_LLMCompletionNode_status(inworld_StatusOr_SharedPtr_LLMCompletionNode* carg1);

SWIGIMPORT inworld_LLMCompletionNode* inworld_StatusOr_SharedPtr_LLMCompletionNode_value(inworld_StatusOr_SharedPtr_LLMCompletionNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionNode* inworld_StatusOr_SharedPtr_LLMCompletionNode_copy(inworld_StatusOr_SharedPtr_LLMCompletionNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_LLMCompletionNode_delete(inworld_StatusOr_SharedPtr_LLMCompletionNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionResponse* inworld_StatusOr_SharedPtr_LLMCompletionResponse_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionResponse* inworld_StatusOr_SharedPtr_LLMCompletionResponse_new_rcstd_shared_ptr_Sl_inworld_graphs_LLMCompletionResponse_Sg_(inworld_LLMCompletionResponse* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionResponse* inworld_StatusOr_SharedPtr_LLMCompletionResponse_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_LLMCompletionResponse_ok(inworld_StatusOr_SharedPtr_LLMCompletionResponse* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_LLMCompletionResponse_status(inworld_StatusOr_SharedPtr_LLMCompletionResponse* carg1);

SWIGIMPORT inworld_LLMCompletionResponse* inworld_StatusOr_SharedPtr_LLMCompletionResponse_value(inworld_StatusOr_SharedPtr_LLMCompletionResponse* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionResponse* inworld_StatusOr_SharedPtr_LLMCompletionResponse_copy(inworld_StatusOr_SharedPtr_LLMCompletionResponse* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_LLMCompletionResponse_delete(inworld_StatusOr_SharedPtr_LLMCompletionResponse* carg1);

SWIGIMPORT void inworld_TypedNode_LLMCompletionResponse_VariantInput_delete(inworld_TypedNode_LLMCompletionResponse_VariantInput* carg1);

SWIGIMPORT const char * inworld_TypedNode_LLMCompletionResponse_VariantInput_id(inworld_TypedNode_LLMCompletionResponse_VariantInput* carg1);

SWIGIMPORT void inworld_LLMCompletionNodeExecutionConfig_llm_component_id_set(inworld_LLMCompletionNodeExecutionConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_LLMCompletionNodeExecutionConfig_llm_component_id_get(inworld_LLMCompletionNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMCompletionNodeExecutionConfig_text_generation_config_set(inworld_LLMCompletionNodeExecutionConfig* carg1, inworld_optional_TextGenerationConfig* carg2);

SWIGIMPORT inworld_optional_TextGenerationConfig* inworld_LLMCompletionNodeExecutionConfig_text_generation_config_get(inworld_LLMCompletionNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMCompletionNodeExecutionConfig_stream_set(inworld_LLMCompletionNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_LLMCompletionNodeExecutionConfig_stream_get(inworld_LLMCompletionNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMCompletionNodeExecutionConfig_prompt_template_set(inworld_LLMCompletionNodeExecutionConfig* carg1, inworld_optional_string* carg2);

SWIGIMPORT inworld_optional_string* inworld_LLMCompletionNodeExecutionConfig_prompt_template_get(inworld_LLMCompletionNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_LLMCompletionNodeExecutionConfig_is_valid(inworld_LLMCompletionNodeExecutionConfig* carg1);

SWIGIMPORT inworld_LLMCompletionNodeExecutionConfig* inworld_LLMCompletionNodeExecutionConfig_new();

SWIGIMPORT inworld_LLMCompletionNodeExecutionConfig* inworld_LLMCompletionNodeExecutionConfig_copy(inworld_LLMCompletionNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMCompletionNodeExecutionConfig_delete(inworld_LLMCompletionNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMCompletionNodeExecutionConfig_report_to_client_set(inworld_LLMCompletionNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_LLMCompletionNodeExecutionConfig_report_to_client_get(inworld_LLMCompletionNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_LLMCompletionNodeExecutionConfig_properties_set(inworld_LLMCompletionNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_LLMCompletionNodeExecutionConfig_properties_get(inworld_LLMCompletionNodeExecutionConfig* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionResponse* inworld_LLMCompletionNode_Process(inworld_LLMCompletionNode* carg1, inworld_ProcessContext* carg2, SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Json_inworld__graphs__Text_inworld__graphs__LLMCompletionRequest_t_t* carg3);

SWIGIMPORT bool inworld_LLMCompletionNode_is_valid(inworld_LLMCompletionNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_LLMCompletionNode* inworld_LLMCompletionNode_Create(const char * carg1, inworld_LLMCompletionNodeExecutionConfig* carg2);

SWIGIMPORT void inworld_LLMCompletionNode_delete(inworld_LLMCompletionNode* carg1);

SWIGIMPORT const char * inworld_LLMCompletionNode_id(inworld_LLMCompletionNode* carg1);

SWIGIMPORT void inworld_TypedNode_ToolCallResponse_ToolCallRequest_delete(inworld_TypedNode_ToolCallResponse_ToolCallRequest* carg1);

SWIGIMPORT const char * inworld_TypedNode_ToolCallResponse_ToolCallRequest_id(inworld_TypedNode_ToolCallResponse_ToolCallRequest* carg1);

SWIGIMPORT void inworld_TypedNode_ListToolsResponse_Text_delete(inworld_TypedNode_ListToolsResponse_Text* carg1);

SWIGIMPORT const char * inworld_TypedNode_ListToolsResponse_Text_id(inworld_TypedNode_ListToolsResponse_Text* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPListToolsNode* inworld_StatusOr_SharedPtr_MCPListToolsNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPListToolsNode* inworld_StatusOr_SharedPtr_MCPListToolsNode_new_rcstd_shared_ptr_Sl_inworld_graphs_MCPListToolsNode_Sg_(inworld_MCPListToolsNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPListToolsNode* inworld_StatusOr_SharedPtr_MCPListToolsNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_MCPListToolsNode_ok(inworld_StatusOr_SharedPtr_MCPListToolsNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_MCPListToolsNode_status(inworld_StatusOr_SharedPtr_MCPListToolsNode* carg1);

SWIGIMPORT inworld_MCPListToolsNode* inworld_StatusOr_SharedPtr_MCPListToolsNode_value(inworld_StatusOr_SharedPtr_MCPListToolsNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPListToolsNode* inworld_StatusOr_SharedPtr_MCPListToolsNode_copy(inworld_StatusOr_SharedPtr_MCPListToolsNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_MCPListToolsNode_delete(inworld_StatusOr_SharedPtr_MCPListToolsNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPCallToolNode* inworld_StatusOr_SharedPtr_MCPCallToolNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPCallToolNode* inworld_StatusOr_SharedPtr_MCPCallToolNode_new_rcstd_shared_ptr_Sl_inworld_graphs_MCPCallToolNode_Sg_(inworld_MCPCallToolNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPCallToolNode* inworld_StatusOr_SharedPtr_MCPCallToolNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_MCPCallToolNode_ok(inworld_StatusOr_SharedPtr_MCPCallToolNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_MCPCallToolNode_status(inworld_StatusOr_SharedPtr_MCPCallToolNode* carg1);

SWIGIMPORT inworld_MCPCallToolNode* inworld_StatusOr_SharedPtr_MCPCallToolNode_value(inworld_StatusOr_SharedPtr_MCPCallToolNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPCallToolNode* inworld_StatusOr_SharedPtr_MCPCallToolNode_copy(inworld_StatusOr_SharedPtr_MCPCallToolNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_MCPCallToolNode_delete(inworld_StatusOr_SharedPtr_MCPCallToolNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_ToolCallResponse* inworld_StatusOr_SharedPtr_ToolCallResponse_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_ToolCallResponse* inworld_StatusOr_SharedPtr_ToolCallResponse_new_rcstd_shared_ptr_Sl_inworld_graphs_ToolCallResponse_Sg_(inworld_ToolCallResponse* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_ToolCallResponse* inworld_StatusOr_SharedPtr_ToolCallResponse_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_ToolCallResponse_ok(inworld_StatusOr_SharedPtr_ToolCallResponse* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_ToolCallResponse_status(inworld_StatusOr_SharedPtr_ToolCallResponse* carg1);

SWIGIMPORT inworld_ToolCallResponse* inworld_StatusOr_SharedPtr_ToolCallResponse_value(inworld_StatusOr_SharedPtr_ToolCallResponse* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_ToolCallResponse* inworld_StatusOr_SharedPtr_ToolCallResponse_copy(inworld_StatusOr_SharedPtr_ToolCallResponse* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_ToolCallResponse_delete(inworld_StatusOr_SharedPtr_ToolCallResponse* carg1);

SWIGIMPORT void inworld_MCPListToolsNodeExecutionConfig_mcp_component_id_set(inworld_MCPListToolsNodeExecutionConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MCPListToolsNodeExecutionConfig_mcp_component_id_get(inworld_MCPListToolsNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_MCPListToolsNodeExecutionConfig_is_valid(inworld_MCPListToolsNodeExecutionConfig* carg1);

SWIGIMPORT inworld_MCPListToolsNodeExecutionConfig* inworld_MCPListToolsNodeExecutionConfig_new();

SWIGIMPORT inworld_MCPListToolsNodeExecutionConfig* inworld_MCPListToolsNodeExecutionConfig_copy(inworld_MCPListToolsNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_MCPListToolsNodeExecutionConfig_delete(inworld_MCPListToolsNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_MCPListToolsNodeExecutionConfig_report_to_client_set(inworld_MCPListToolsNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_MCPListToolsNodeExecutionConfig_report_to_client_get(inworld_MCPListToolsNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_MCPListToolsNodeExecutionConfig_properties_set(inworld_MCPListToolsNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_MCPListToolsNodeExecutionConfig_properties_get(inworld_MCPListToolsNodeExecutionConfig* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_MCPListToolsNode_Process(inworld_MCPListToolsNode* carg1, inworld_ProcessContext* carg2, inworld_vector_BaseData* carg3);

SWIGIMPORT bool inworld_MCPListToolsNode_is_valid(inworld_MCPListToolsNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPListToolsNode* inworld_MCPListToolsNode_Create(const char * carg1, inworld_MCPListToolsNodeExecutionConfig* carg2);

SWIGIMPORT void inworld_MCPListToolsNode_delete(inworld_MCPListToolsNode* carg1);

SWIGIMPORT const char * inworld_MCPListToolsNode_id(inworld_MCPListToolsNode* carg1);

SWIGIMPORT void inworld_MCPCallToolNodeExecutionConfig_mcp_component_id_set(inworld_MCPCallToolNodeExecutionConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MCPCallToolNodeExecutionConfig_mcp_component_id_get(inworld_MCPCallToolNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_MCPCallToolNodeExecutionConfig_is_valid(inworld_MCPCallToolNodeExecutionConfig* carg1);

SWIGIMPORT inworld_MCPCallToolNodeExecutionConfig* inworld_MCPCallToolNodeExecutionConfig_new();

SWIGIMPORT inworld_MCPCallToolNodeExecutionConfig* inworld_MCPCallToolNodeExecutionConfig_copy(inworld_MCPCallToolNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_MCPCallToolNodeExecutionConfig_delete(inworld_MCPCallToolNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_MCPCallToolNodeExecutionConfig_report_to_client_set(inworld_MCPCallToolNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_MCPCallToolNodeExecutionConfig_report_to_client_get(inworld_MCPCallToolNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_MCPCallToolNodeExecutionConfig_properties_set(inworld_MCPCallToolNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_MCPCallToolNodeExecutionConfig_properties_get(inworld_MCPCallToolNodeExecutionConfig* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_ToolCallResponse* inworld_MCPCallToolNode_Process(inworld_MCPCallToolNode* carg1, inworld_ProcessContext* carg2, inworld_ToolCallRequest* carg3);

SWIGIMPORT bool inworld_MCPCallToolNode_is_valid(inworld_MCPCallToolNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MCPCallToolNode* inworld_MCPCallToolNode_Create(const char * carg1, inworld_MCPCallToolNodeExecutionConfig* carg2);

SWIGIMPORT void inworld_MCPCallToolNode_delete(inworld_MCPCallToolNode* carg1);

SWIGIMPORT const char * inworld_MCPCallToolNode_id(inworld_MCPCallToolNode* carg1);

SWIGIMPORT void inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text_delete(inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text* carg1);

SWIGIMPORT const char * inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text_id(inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text* carg1);

SWIGIMPORT void inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text_delete(inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text* carg1);

SWIGIMPORT const char * inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text_id(inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryUpdateNode* inworld_StatusOr_SharedPtr_MemoryUpdateNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryUpdateNode* inworld_StatusOr_SharedPtr_MemoryUpdateNode_new_rcstd_shared_ptr_Sl_inworld_graphs_MemoryUpdateNode_Sg_(inworld_MemoryUpdateNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryUpdateNode* inworld_StatusOr_SharedPtr_MemoryUpdateNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_MemoryUpdateNode_ok(inworld_StatusOr_SharedPtr_MemoryUpdateNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_MemoryUpdateNode_status(inworld_StatusOr_SharedPtr_MemoryUpdateNode* carg1);

SWIGIMPORT inworld_MemoryUpdateNode* inworld_StatusOr_SharedPtr_MemoryUpdateNode_value(inworld_StatusOr_SharedPtr_MemoryUpdateNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryUpdateNode* inworld_StatusOr_SharedPtr_MemoryUpdateNode_copy(inworld_StatusOr_SharedPtr_MemoryUpdateNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_MemoryUpdateNode_delete(inworld_StatusOr_SharedPtr_MemoryUpdateNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryRetrieveNode* inworld_StatusOr_SharedPtr_MemoryRetrieveNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryRetrieveNode* inworld_StatusOr_SharedPtr_MemoryRetrieveNode_new_rcstd_shared_ptr_Sl_inworld_graphs_MemoryRetrieveNode_Sg_(inworld_MemoryRetrieveNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryRetrieveNode* inworld_StatusOr_SharedPtr_MemoryRetrieveNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_MemoryRetrieveNode_ok(inworld_StatusOr_SharedPtr_MemoryRetrieveNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_MemoryRetrieveNode_status(inworld_StatusOr_SharedPtr_MemoryRetrieveNode* carg1);

SWIGIMPORT inworld_MemoryRetrieveNode* inworld_StatusOr_SharedPtr_MemoryRetrieveNode_value(inworld_StatusOr_SharedPtr_MemoryRetrieveNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryRetrieveNode* inworld_StatusOr_SharedPtr_MemoryRetrieveNode_copy(inworld_StatusOr_SharedPtr_MemoryRetrieveNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_MemoryRetrieveNode_delete(inworld_StatusOr_SharedPtr_MemoryRetrieveNode* carg1);

SWIGIMPORT void inworld_MemoryUpdateNodeCreationConfig_llm_component_id_set(inworld_MemoryUpdateNodeCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MemoryUpdateNodeCreationConfig_llm_component_id_get(inworld_MemoryUpdateNodeCreationConfig* carg1);

SWIGIMPORT void inworld_MemoryUpdateNodeCreationConfig_embedder_component_id_set(inworld_MemoryUpdateNodeCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MemoryUpdateNodeCreationConfig_embedder_component_id_get(inworld_MemoryUpdateNodeCreationConfig* carg1);

SWIGIMPORT void inworld_MemoryUpdateNodeCreationConfig_memory_update_config_set(inworld_MemoryUpdateNodeCreationConfig* carg1, inworld_MemoryUpdateConfig* carg2);

SWIGIMPORT inworld_MemoryUpdateConfig* inworld_MemoryUpdateNodeCreationConfig_memory_update_config_get(inworld_MemoryUpdateNodeCreationConfig* carg1);

SWIGIMPORT inworld_MemoryUpdateNodeCreationConfig* inworld_MemoryUpdateNodeCreationConfig_new();

SWIGIMPORT inworld_MemoryUpdateNodeCreationConfig* inworld_MemoryUpdateNodeCreationConfig_copy(inworld_MemoryUpdateNodeCreationConfig* carg1);

SWIGIMPORT void inworld_MemoryUpdateNodeCreationConfig_delete(inworld_MemoryUpdateNodeCreationConfig* carg1);

SWIGIMPORT void inworld_MemoryRetrieveNodeCreationConfig_llm_component_id_set(inworld_MemoryRetrieveNodeCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MemoryRetrieveNodeCreationConfig_llm_component_id_get(inworld_MemoryRetrieveNodeCreationConfig* carg1);

SWIGIMPORT void inworld_MemoryRetrieveNodeCreationConfig_embedder_component_id_set(inworld_MemoryRetrieveNodeCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_MemoryRetrieveNodeCreationConfig_embedder_component_id_get(inworld_MemoryRetrieveNodeCreationConfig* carg1);

SWIGIMPORT inworld_MemoryRetrieveNodeCreationConfig* inworld_MemoryRetrieveNodeCreationConfig_new();

SWIGIMPORT inworld_MemoryRetrieveNodeCreationConfig* inworld_MemoryRetrieveNodeCreationConfig_copy(inworld_MemoryRetrieveNodeCreationConfig* carg1);

SWIGIMPORT void inworld_MemoryRetrieveNodeCreationConfig_delete(inworld_MemoryRetrieveNodeCreationConfig* carg1);

SWIGIMPORT void inworld_MemoryRetrieveNodeExecutionConfig_retrieval_config_set(inworld_MemoryRetrieveNodeExecutionConfig* carg1, inworld_RetrievalConfig* carg2);

SWIGIMPORT inworld_RetrievalConfig* inworld_MemoryRetrieveNodeExecutionConfig_retrieval_config_get(inworld_MemoryRetrieveNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_MemoryRetrieveNodeExecutionConfig_return_rolling_summary_set(inworld_MemoryRetrieveNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_MemoryRetrieveNodeExecutionConfig_return_rolling_summary_get(inworld_MemoryRetrieveNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_MemoryRetrieveNodeExecutionConfig_is_valid(inworld_MemoryRetrieveNodeExecutionConfig* carg1);

SWIGIMPORT inworld_MemoryRetrieveNodeExecutionConfig* inworld_MemoryRetrieveNodeExecutionConfig_new();

SWIGIMPORT inworld_MemoryRetrieveNodeExecutionConfig* inworld_MemoryRetrieveNodeExecutionConfig_copy(inworld_MemoryRetrieveNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_MemoryRetrieveNodeExecutionConfig_delete(inworld_MemoryRetrieveNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_MemoryRetrieveNodeExecutionConfig_report_to_client_set(inworld_MemoryRetrieveNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_MemoryRetrieveNodeExecutionConfig_report_to_client_get(inworld_MemoryRetrieveNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_MemoryRetrieveNodeExecutionConfig_properties_set(inworld_MemoryRetrieveNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_MemoryRetrieveNodeExecutionConfig_properties_get(inworld_MemoryRetrieveNodeExecutionConfig* carg1);

SWIGIMPORT SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__MemoryState_t_t* inworld_MemoryUpdateNode_Process(inworld_MemoryUpdateNode* carg1, inworld_ProcessContext* carg2, inworld_EventHistory* carg3, inworld_MemoryState* carg4, inworld_Text* carg5, inworld_Text* carg6, inworld_Text* carg7, inworld_Text* carg8);

SWIGIMPORT bool inworld_MemoryUpdateNode_is_valid(inworld_MemoryUpdateNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryUpdateNode* inworld_MemoryUpdateNode_Create_rcstd_string_rcinworld_CreationContext_rcinworld_graphs_MemoryUpdateNodeCreationConfig(const char * carg1, inworld_CreationContext* carg2, inworld_MemoryUpdateNodeCreationConfig* carg3);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryUpdateNode* inworld_MemoryUpdateNode_Create_rcstd_string_rcinworld_CreationContext_rcinworld_graphs_MemoryUpdateNodeCreationConfig_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg_(const char * carg1, inworld_CreationContext* carg2, inworld_MemoryUpdateNodeCreationConfig* carg3, inworld_NodeExecutionConfig* carg4);

SWIGIMPORT inworld_MemoryUpdateNode* inworld_MemoryUpdateNode_copy(inworld_MemoryUpdateNode* carg1);

SWIGIMPORT void inworld_MemoryUpdateNode_delete(inworld_MemoryUpdateNode* carg1);

SWIGIMPORT const char * inworld_MemoryUpdateNode_id(inworld_MemoryUpdateNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_KnowledgeRecords* inworld_MemoryRetrieveNode_Process(inworld_MemoryRetrieveNode* carg1, inworld_ProcessContext* carg2, inworld_EventHistory* carg3, inworld_MemoryState* carg4, inworld_Text* carg5, inworld_Text* carg6);

SWIGIMPORT bool inworld_MemoryRetrieveNode_is_valid(inworld_MemoryRetrieveNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_MemoryRetrieveNode* inworld_MemoryRetrieveNode_Create(const char * carg1, inworld_CreationContext* carg2, inworld_MemoryRetrieveNodeCreationConfig* carg3, inworld_MemoryRetrieveNodeExecutionConfig* carg4);

SWIGIMPORT inworld_MemoryRetrieveNode* inworld_MemoryRetrieveNode_copy(inworld_MemoryRetrieveNode* carg1);

SWIGIMPORT void inworld_MemoryRetrieveNode_delete(inworld_MemoryRetrieveNode* carg1);

SWIGIMPORT const char * inworld_MemoryRetrieveNode_id(inworld_MemoryRetrieveNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_RandomCannedTextNode* inworld_StatusOr_SharedPtr_RandomCannedTextNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_RandomCannedTextNode* inworld_StatusOr_SharedPtr_RandomCannedTextNode_new_rcstd_shared_ptr_Sl_inworld_graphs_RandomCannedTextNode_Sg_(inworld_RandomCannedTextNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_RandomCannedTextNode* inworld_StatusOr_SharedPtr_RandomCannedTextNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_RandomCannedTextNode_ok(inworld_StatusOr_SharedPtr_RandomCannedTextNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_RandomCannedTextNode_status(inworld_StatusOr_SharedPtr_RandomCannedTextNode* carg1);

SWIGIMPORT inworld_RandomCannedTextNode* inworld_StatusOr_SharedPtr_RandomCannedTextNode_value(inworld_StatusOr_SharedPtr_RandomCannedTextNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_RandomCannedTextNode* inworld_StatusOr_SharedPtr_RandomCannedTextNode_copy(inworld_StatusOr_SharedPtr_RandomCannedTextNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_RandomCannedTextNode_delete(inworld_StatusOr_SharedPtr_RandomCannedTextNode* carg1);

SWIGIMPORT void inworld_RandomCannedTextNodeExecutionConfig_canned_phrases_set(inworld_RandomCannedTextNodeExecutionConfig* carg1, inworld_vector_string* carg2);

SWIGIMPORT inworld_vector_string* inworld_RandomCannedTextNodeExecutionConfig_canned_phrases_get(inworld_RandomCannedTextNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_RandomCannedTextNodeExecutionConfig_is_valid(inworld_RandomCannedTextNodeExecutionConfig* carg1);

SWIGIMPORT inworld_RandomCannedTextNodeExecutionConfig* inworld_RandomCannedTextNodeExecutionConfig_new();

SWIGIMPORT inworld_RandomCannedTextNodeExecutionConfig* inworld_RandomCannedTextNodeExecutionConfig_copy(inworld_RandomCannedTextNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_RandomCannedTextNodeExecutionConfig_delete(inworld_RandomCannedTextNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_RandomCannedTextNodeExecutionConfig_report_to_client_set(inworld_RandomCannedTextNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_RandomCannedTextNodeExecutionConfig_report_to_client_get(inworld_RandomCannedTextNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_RandomCannedTextNodeExecutionConfig_properties_set(inworld_RandomCannedTextNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_RandomCannedTextNodeExecutionConfig_properties_get(inworld_RandomCannedTextNodeExecutionConfig* carg1);

SWIGIMPORT inworld_StatusOr_BaseData* inworld_RandomCannedTextNode_Process(inworld_RandomCannedTextNode* carg1, inworld_ProcessContext* carg2, inworld_vector_BaseData* carg3);

SWIGIMPORT bool inworld_RandomCannedTextNode_is_valid(inworld_RandomCannedTextNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_RandomCannedTextNode* inworld_RandomCannedTextNode_Create(const char * carg1, inworld_RandomCannedTextNodeExecutionConfig* carg2);

SWIGIMPORT inworld_RandomCannedTextNode* inworld_RandomCannedTextNode_copy(inworld_RandomCannedTextNode* carg1);

SWIGIMPORT void inworld_RandomCannedTextNode_delete(inworld_RandomCannedTextNode* carg1);

SWIGIMPORT const char * inworld_RandomCannedTextNode_id(inworld_RandomCannedTextNode* carg1);

SWIGIMPORT void inworld_TypedNode_SafetyResult_delete(inworld_TypedNode_SafetyResult* carg1);

SWIGIMPORT const char * inworld_TypedNode_SafetyResult_id(inworld_TypedNode_SafetyResult* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyCheckerNode* inworld_StatusOr_SharedPtr_SafetyCheckerNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyCheckerNode* inworld_StatusOr_SharedPtr_SafetyCheckerNode_new_rcstd_shared_ptr_Sl_inworld_graphs_SafetyCheckerNode_Sg_(inworld_SafetyCheckerNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyCheckerNode* inworld_StatusOr_SharedPtr_SafetyCheckerNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_SafetyCheckerNode_ok(inworld_StatusOr_SharedPtr_SafetyCheckerNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_SafetyCheckerNode_status(inworld_StatusOr_SharedPtr_SafetyCheckerNode* carg1);

SWIGIMPORT inworld_SafetyCheckerNode* inworld_StatusOr_SharedPtr_SafetyCheckerNode_value(inworld_StatusOr_SharedPtr_SafetyCheckerNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyCheckerNode* inworld_StatusOr_SharedPtr_SafetyCheckerNode_copy(inworld_StatusOr_SharedPtr_SafetyCheckerNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_SafetyCheckerNode_delete(inworld_StatusOr_SharedPtr_SafetyCheckerNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyResult* inworld_StatusOr_SharedPtr_SafetyResult_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyResult* inworld_StatusOr_SharedPtr_SafetyResult_new_rcstd_shared_ptr_Sl_inworld_graphs_SafetyResult_Sg_(inworld_SafetyResult* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyResult* inworld_StatusOr_SharedPtr_SafetyResult_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_SafetyResult_ok(inworld_StatusOr_SharedPtr_SafetyResult* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_SafetyResult_status(inworld_StatusOr_SharedPtr_SafetyResult* carg1);

SWIGIMPORT inworld_SafetyResult* inworld_StatusOr_SharedPtr_SafetyResult_value(inworld_StatusOr_SharedPtr_SafetyResult* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyResult* inworld_StatusOr_SharedPtr_SafetyResult_copy(inworld_StatusOr_SharedPtr_SafetyResult* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_SafetyResult_delete(inworld_StatusOr_SharedPtr_SafetyResult* carg1);

SWIGIMPORT inworld_optional_SafetyConfig* inworld_optional_SafetyConfig_new();

SWIGIMPORT inworld_optional_SafetyConfig* inworld_optional_SafetyConfig_new_rcinworld_SafetyConfig(inworld_SafetyConfig* carg1);

SWIGIMPORT inworld_optional_SafetyConfig* inworld_optional_SafetyConfig_copy(inworld_optional_SafetyConfig* carg1);

SWIGIMPORT void inworld_optional_SafetyConfig_delete(inworld_optional_SafetyConfig* carg1);

SWIGIMPORT bool inworld_optional_SafetyConfig_has_value(inworld_optional_SafetyConfig* carg1);

SWIGIMPORT inworld_SafetyConfig* inworld_optional_SafetyConfig_value(inworld_optional_SafetyConfig* carg1);

SWIGIMPORT inworld_SafetyConfig* inworld_optional_SafetyConfig_valueConst(inworld_optional_SafetyConfig* carg1);

SWIGIMPORT inworld_SafetyConfig* inworld_optional_SafetyConfig_value_or(inworld_optional_SafetyConfig* carg1, inworld_SafetyConfig* carg2);

SWIGIMPORT void inworld_optional_SafetyConfig_reset(inworld_optional_SafetyConfig* carg1);

SWIGIMPORT inworld_SafetyConfig* inworld_optional_SafetyConfig_get(inworld_optional_SafetyConfig* carg1);

SWIGIMPORT inworld_SafetyConfig* inworld_optional_SafetyConfig_getConst(inworld_optional_SafetyConfig* carg1);

SWIGIMPORT inworld_SafetyConfig* inworld_optional_SafetyConfig_get_value(inworld_optional_SafetyConfig* carg1);

SWIGIMPORT void inworld_optional_SafetyConfig_set_value(inworld_optional_SafetyConfig* carg1, inworld_SafetyConfig* carg2);

SWIGIMPORT void inworld_SafetyCheckerNodeCreationConfig_embedder_component_id_set(inworld_SafetyCheckerNodeCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_SafetyCheckerNodeCreationConfig_embedder_component_id_get(inworld_SafetyCheckerNodeCreationConfig* carg1);

SWIGIMPORT void inworld_SafetyCheckerNodeCreationConfig_safety_config_set(inworld_SafetyCheckerNodeCreationConfig* carg1, inworld_SafetyCheckerCreationConfig* carg2);

SWIGIMPORT inworld_SafetyCheckerCreationConfig* inworld_SafetyCheckerNodeCreationConfig_safety_config_get(inworld_SafetyCheckerNodeCreationConfig* carg1);

SWIGIMPORT inworld_SafetyCheckerNodeCreationConfig* inworld_SafetyCheckerNodeCreationConfig_new();

SWIGIMPORT inworld_SafetyCheckerNodeCreationConfig* inworld_SafetyCheckerNodeCreationConfig_copy(inworld_SafetyCheckerNodeCreationConfig* carg1);

SWIGIMPORT void inworld_SafetyCheckerNodeCreationConfig_delete(inworld_SafetyCheckerNodeCreationConfig* carg1);

SWIGIMPORT void inworld_SafetyCheckerNodeExecutionConfig_safety_config_set(inworld_SafetyCheckerNodeExecutionConfig* carg1, inworld_optional_SafetyConfig* carg2);

SWIGIMPORT inworld_optional_SafetyConfig* inworld_SafetyCheckerNodeExecutionConfig_safety_config_get(inworld_SafetyCheckerNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_SafetyCheckerNodeExecutionConfig_is_valid(inworld_SafetyCheckerNodeExecutionConfig* carg1);

SWIGIMPORT inworld_SafetyCheckerNodeExecutionConfig* inworld_SafetyCheckerNodeExecutionConfig_new();

SWIGIMPORT inworld_SafetyCheckerNodeExecutionConfig* inworld_SafetyCheckerNodeExecutionConfig_copy(inworld_SafetyCheckerNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_SafetyCheckerNodeExecutionConfig_delete(inworld_SafetyCheckerNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_SafetyCheckerNodeExecutionConfig_report_to_client_set(inworld_SafetyCheckerNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_SafetyCheckerNodeExecutionConfig_report_to_client_get(inworld_SafetyCheckerNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_SafetyCheckerNodeExecutionConfig_properties_set(inworld_SafetyCheckerNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_SafetyCheckerNodeExecutionConfig_properties_get(inworld_SafetyCheckerNodeExecutionConfig* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyResult* inworld_SafetyCheckerNode_Process(inworld_SafetyCheckerNode* carg1, inworld_ProcessContext* carg2, inworld_Text* carg3);

SWIGIMPORT bool inworld_SafetyCheckerNode_is_valid(inworld_SafetyCheckerNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_SafetyCheckerNode* inworld_SafetyCheckerNode_Create(const char * carg1, inworld_CreationContext* carg2, inworld_SafetyCheckerNodeCreationConfig* carg3, inworld_SafetyCheckerNodeExecutionConfig* carg4);

SWIGIMPORT inworld_SafetyCheckerNode* inworld_SafetyCheckerNode_copy(inworld_SafetyCheckerNode* carg1);

SWIGIMPORT void inworld_SafetyCheckerNode_delete(inworld_SafetyCheckerNode* carg1);

SWIGIMPORT const char * inworld_SafetyCheckerNode_id(inworld_SafetyCheckerNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_STTNode* inworld_StatusOr_SharedPtr_STTNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_STTNode* inworld_StatusOr_SharedPtr_STTNode_new_rcstd_shared_ptr_Sl_inworld_graphs_STTNode_Sg_(inworld_STTNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_STTNode* inworld_StatusOr_SharedPtr_STTNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_STTNode_ok(inworld_StatusOr_SharedPtr_STTNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_STTNode_status(inworld_StatusOr_SharedPtr_STTNode* carg1);

SWIGIMPORT inworld_STTNode* inworld_StatusOr_SharedPtr_STTNode_value(inworld_StatusOr_SharedPtr_STTNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_STTNode* inworld_StatusOr_SharedPtr_STTNode_copy(inworld_StatusOr_SharedPtr_STTNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_STTNode_delete(inworld_StatusOr_SharedPtr_STTNode* carg1);

SWIGIMPORT void inworld_STTNodeExecutionConfig_stt_component_id_set(inworld_STTNodeExecutionConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_STTNodeExecutionConfig_stt_component_id_get(inworld_STTNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_STTNodeExecutionConfig_speech_recognition_config_set(inworld_STTNodeExecutionConfig* carg1, inworld_optional_SpeechRecognitionConfig* carg2);

SWIGIMPORT inworld_optional_SpeechRecognitionConfig* inworld_STTNodeExecutionConfig_speech_recognition_config_get(inworld_STTNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_STTNodeExecutionConfig_is_valid(inworld_STTNodeExecutionConfig* carg1);

SWIGIMPORT inworld_STTNodeExecutionConfig* inworld_STTNodeExecutionConfig_new();

SWIGIMPORT inworld_STTNodeExecutionConfig* inworld_STTNodeExecutionConfig_copy(inworld_STTNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_STTNodeExecutionConfig_delete(inworld_STTNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_STTNodeExecutionConfig_report_to_client_set(inworld_STTNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_STTNodeExecutionConfig_report_to_client_get(inworld_STTNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_STTNodeExecutionConfig_properties_set(inworld_STTNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_STTNodeExecutionConfig_properties_get(inworld_STTNodeExecutionConfig* carg1);

SWIGIMPORT SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__Text_t_t* inworld_STTNode_Process(inworld_STTNode* carg1, inworld_ProcessContext* carg2, SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Audio_inworld__graphs__DataStreamT_inworld__AudioChunk_t_inworld__graphs__STTRequest_t_t* carg3);

SWIGIMPORT bool inworld_STTNode_is_valid(inworld_STTNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_STTNode* inworld_STTNode_Create(const char * carg1, inworld_STTNodeExecutionConfig* carg2);

SWIGIMPORT inworld_STTNode* inworld_STTNode_copy(inworld_STTNode* carg1);

SWIGIMPORT void inworld_STTNode_delete(inworld_STTNode* carg1);

SWIGIMPORT const char * inworld_STTNode_id(inworld_STTNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextAggregatorNode* inworld_StatusOr_SharedPtr_TextAggregatorNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_TextAggregatorNode* inworld_StatusOr_SharedPtr_TextAggregatorNode_new_rcstd_shared_ptr_Sl_inworld_graphs_TextAggregatorNode_Sg_(inworld_TextAggregatorNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextAggregatorNode* inworld_StatusOr_SharedPtr_TextAggregatorNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_TextAggregatorNode_ok(inworld_StatusOr_SharedPtr_TextAggregatorNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_TextAggregatorNode_status(inworld_StatusOr_SharedPtr_TextAggregatorNode* carg1);

SWIGIMPORT inworld_TextAggregatorNode* inworld_StatusOr_SharedPtr_TextAggregatorNode_value(inworld_StatusOr_SharedPtr_TextAggregatorNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextAggregatorNode* inworld_StatusOr_SharedPtr_TextAggregatorNode_copy(inworld_StatusOr_SharedPtr_TextAggregatorNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_TextAggregatorNode_delete(inworld_StatusOr_SharedPtr_TextAggregatorNode* carg1);

SWIGIMPORT SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__Text_t_t* inworld_TextAggregatorNode_Process(inworld_TextAggregatorNode* carg1, inworld_ProcessContext* carg2, SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Text_inworld__graphs__DataStreamT_std__string_t_inworld__graphs__LLMCompletionResponse_inworld__graphs__LLMChatResponse_t_t* carg3);

SWIGIMPORT bool inworld_TextAggregatorNode_is_valid(inworld_TextAggregatorNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextAggregatorNode* inworld_TextAggregatorNode_Create(const char * carg1, inworld_NodeExecutionConfig* carg2);

SWIGIMPORT inworld_TextAggregatorNode* inworld_TextAggregatorNode_copy(inworld_TextAggregatorNode* carg1);

SWIGIMPORT void inworld_TextAggregatorNode_delete(inworld_TextAggregatorNode* carg1);

SWIGIMPORT const char * inworld_TextAggregatorNode_id(inworld_TextAggregatorNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextChunkingNode* inworld_StatusOr_SharedPtr_TextChunkingNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_TextChunkingNode* inworld_StatusOr_SharedPtr_TextChunkingNode_new_rcstd_shared_ptr_Sl_inworld_graphs_TextChunkingNode_Sg_(inworld_TextChunkingNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextChunkingNode* inworld_StatusOr_SharedPtr_TextChunkingNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_TextChunkingNode_ok(inworld_StatusOr_SharedPtr_TextChunkingNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_TextChunkingNode_status(inworld_StatusOr_SharedPtr_TextChunkingNode* carg1);

SWIGIMPORT inworld_TextChunkingNode* inworld_StatusOr_SharedPtr_TextChunkingNode_value(inworld_StatusOr_SharedPtr_TextChunkingNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextChunkingNode* inworld_StatusOr_SharedPtr_TextChunkingNode_copy(inworld_StatusOr_SharedPtr_TextChunkingNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_TextChunkingNode_delete(inworld_StatusOr_SharedPtr_TextChunkingNode* carg1);

SWIGIMPORT void inworld_TextChunkingNodeExecutionConfig_min_chunk_length_set(inworld_TextChunkingNodeExecutionConfig* carg1, inworld_optional_int* carg2);

SWIGIMPORT inworld_optional_int* inworld_TextChunkingNodeExecutionConfig_min_chunk_length_get(inworld_TextChunkingNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_TextChunkingNodeExecutionConfig_is_valid(inworld_TextChunkingNodeExecutionConfig* carg1);

SWIGIMPORT inworld_TextChunkingNodeExecutionConfig* inworld_TextChunkingNodeExecutionConfig_new();

SWIGIMPORT inworld_TextChunkingNodeExecutionConfig* inworld_TextChunkingNodeExecutionConfig_copy(inworld_TextChunkingNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TextChunkingNodeExecutionConfig_delete(inworld_TextChunkingNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TextChunkingNodeExecutionConfig_report_to_client_set(inworld_TextChunkingNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_TextChunkingNodeExecutionConfig_report_to_client_get(inworld_TextChunkingNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TextChunkingNodeExecutionConfig_properties_set(inworld_TextChunkingNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_TextChunkingNodeExecutionConfig_properties_get(inworld_TextChunkingNodeExecutionConfig* carg1);

SWIGIMPORT SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__DataStreamT_std__string_t_t_t* inworld_TextChunkingNode_Process(inworld_TextChunkingNode* carg1, inworld_ProcessContext* carg2, SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Text_inworld__graphs__DataStreamT_std__string_t_inworld__graphs__LLMCompletionResponse_inworld__graphs__LLMChatResponse_t_t* carg3);

SWIGIMPORT bool inworld_TextChunkingNode_is_valid(inworld_TextChunkingNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextChunkingNode* inworld_TextChunkingNode_Create(const char * carg1, inworld_TextChunkingNodeExecutionConfig* carg2);

SWIGIMPORT inworld_TextChunkingNode* inworld_TextChunkingNode_copy(inworld_TextChunkingNode* carg1);

SWIGIMPORT void inworld_TextChunkingNode_delete(inworld_TextChunkingNode* carg1);

SWIGIMPORT const char * inworld_TextChunkingNode_id(inworld_TextChunkingNode* carg1);

SWIGIMPORT void inworld_TypedNode_ClassificationResult_delete(inworld_TypedNode_ClassificationResult* carg1);

SWIGIMPORT const char * inworld_TypedNode_ClassificationResult_id(inworld_TypedNode_ClassificationResult* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextClassifierNode* inworld_StatusOr_SharedPtr_TextClassifierNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_TextClassifierNode* inworld_StatusOr_SharedPtr_TextClassifierNode_new_rcstd_shared_ptr_Sl_inworld_graphs_TextClassifierNode_Sg_(inworld_TextClassifierNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextClassifierNode* inworld_StatusOr_SharedPtr_TextClassifierNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_TextClassifierNode_ok(inworld_StatusOr_SharedPtr_TextClassifierNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_TextClassifierNode_status(inworld_StatusOr_SharedPtr_TextClassifierNode* carg1);

SWIGIMPORT inworld_TextClassifierNode* inworld_StatusOr_SharedPtr_TextClassifierNode_value(inworld_StatusOr_SharedPtr_TextClassifierNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextClassifierNode* inworld_StatusOr_SharedPtr_TextClassifierNode_copy(inworld_StatusOr_SharedPtr_TextClassifierNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_TextClassifierNode_delete(inworld_StatusOr_SharedPtr_TextClassifierNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_ClassificationResult* inworld_StatusOr_SharedPtr_ClassificationResult_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_ClassificationResult* inworld_StatusOr_SharedPtr_ClassificationResult_new_rcstd_shared_ptr_Sl_inworld_graphs_ClassificationResult_Sg_(inworld_ClassificationResult* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_ClassificationResult* inworld_StatusOr_SharedPtr_ClassificationResult_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_ClassificationResult_ok(inworld_StatusOr_SharedPtr_ClassificationResult* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_ClassificationResult_status(inworld_StatusOr_SharedPtr_ClassificationResult* carg1);

SWIGIMPORT inworld_ClassificationResult* inworld_StatusOr_SharedPtr_ClassificationResult_value(inworld_StatusOr_SharedPtr_ClassificationResult* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_ClassificationResult* inworld_StatusOr_SharedPtr_ClassificationResult_copy(inworld_StatusOr_SharedPtr_ClassificationResult* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_ClassificationResult_delete(inworld_StatusOr_SharedPtr_ClassificationResult* carg1);

SWIGIMPORT void inworld_TextClassifierNodeCreationConfig_embedder_component_id_set(inworld_TextClassifierNodeCreationConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TextClassifierNodeCreationConfig_embedder_component_id_get(inworld_TextClassifierNodeCreationConfig* carg1);

SWIGIMPORT void inworld_TextClassifierNodeCreationConfig_classifier_config_set(inworld_TextClassifierNodeCreationConfig* carg1, inworld_TextClassifierCreationConfig* carg2);

SWIGIMPORT inworld_TextClassifierCreationConfig* inworld_TextClassifierNodeCreationConfig_classifier_config_get(inworld_TextClassifierNodeCreationConfig* carg1);

SWIGIMPORT inworld_TextClassifierNodeCreationConfig* inworld_TextClassifierNodeCreationConfig_new();

SWIGIMPORT inworld_TextClassifierNodeCreationConfig* inworld_TextClassifierNodeCreationConfig_copy(inworld_TextClassifierNodeCreationConfig* carg1);

SWIGIMPORT void inworld_TextClassifierNodeCreationConfig_delete(inworld_TextClassifierNodeCreationConfig* carg1);

SWIGIMPORT void inworld_TextClassifierNodeExecutionConfig_classifier_config_set(inworld_TextClassifierNodeExecutionConfig* carg1, inworld_optional_TextClassifierConfig* carg2);

SWIGIMPORT inworld_optional_TextClassifierConfig* inworld_TextClassifierNodeExecutionConfig_classifier_config_get(inworld_TextClassifierNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_TextClassifierNodeExecutionConfig_is_valid(inworld_TextClassifierNodeExecutionConfig* carg1);

SWIGIMPORT inworld_TextClassifierNodeExecutionConfig* inworld_TextClassifierNodeExecutionConfig_new();

SWIGIMPORT inworld_TextClassifierNodeExecutionConfig* inworld_TextClassifierNodeExecutionConfig_copy(inworld_TextClassifierNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TextClassifierNodeExecutionConfig_delete(inworld_TextClassifierNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TextClassifierNodeExecutionConfig_report_to_client_set(inworld_TextClassifierNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_TextClassifierNodeExecutionConfig_report_to_client_get(inworld_TextClassifierNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TextClassifierNodeExecutionConfig_properties_set(inworld_TextClassifierNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_TextClassifierNodeExecutionConfig_properties_get(inworld_TextClassifierNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TextClassifierNode_delete(inworld_TextClassifierNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TextClassifierNode* inworld_TextClassifierNode_Create(const char * carg1, inworld_CreationContext* carg2, inworld_TextClassifierNodeCreationConfig* carg3, inworld_TextClassifierNodeExecutionConfig* carg4);

SWIGIMPORT inworld_StatusOr_SharedPtr_ClassificationResult* inworld_TextClassifierNode_Process(inworld_TextClassifierNode* carg1, inworld_ProcessContext* carg2, inworld_Text* carg3);

SWIGIMPORT bool inworld_TextClassifierNode_is_valid(inworld_TextClassifierNode* carg1);

SWIGIMPORT inworld_TextClassifierNode* inworld_TextClassifierNode_copy(inworld_TextClassifierNode* carg1);

SWIGIMPORT const char * inworld_TextClassifierNode_id(inworld_TextClassifierNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TTSNode* inworld_StatusOr_SharedPtr_TTSNode_new();

SWIGIMPORT inworld_StatusOr_SharedPtr_TTSNode* inworld_StatusOr_SharedPtr_TTSNode_new_rcstd_shared_ptr_Sl_inworld_graphs_TTSNode_Sg_(inworld_TTSNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TTSNode* inworld_StatusOr_SharedPtr_TTSNode_new_rcabsl_Status(inworld_Status* carg1);

SWIGIMPORT bool inworld_StatusOr_SharedPtr_TTSNode_ok(inworld_StatusOr_SharedPtr_TTSNode* carg1);

SWIGIMPORT inworld_Status* inworld_StatusOr_SharedPtr_TTSNode_status(inworld_StatusOr_SharedPtr_TTSNode* carg1);

SWIGIMPORT inworld_TTSNode* inworld_StatusOr_SharedPtr_TTSNode_value(inworld_StatusOr_SharedPtr_TTSNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TTSNode* inworld_StatusOr_SharedPtr_TTSNode_copy(inworld_StatusOr_SharedPtr_TTSNode* carg1);

SWIGIMPORT void inworld_StatusOr_SharedPtr_TTSNode_delete(inworld_StatusOr_SharedPtr_TTSNode* carg1);

SWIGIMPORT void inworld_TTSNodeExecutionConfig_tts_component_id_set(inworld_TTSNodeExecutionConfig* carg1, const char * carg2);

SWIGIMPORT const char * inworld_TTSNodeExecutionConfig_tts_component_id_get(inworld_TTSNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TTSNodeExecutionConfig_voice_set(inworld_TTSNodeExecutionConfig* carg1, inworld_Voice* carg2);

SWIGIMPORT inworld_Voice* inworld_TTSNodeExecutionConfig_voice_get(inworld_TTSNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TTSNodeExecutionConfig_synthesis_config_set(inworld_TTSNodeExecutionConfig* carg1, inworld_optional_SpeechSynthesisConfig* carg2);

SWIGIMPORT inworld_optional_SpeechSynthesisConfig* inworld_TTSNodeExecutionConfig_synthesis_config_get(inworld_TTSNodeExecutionConfig* carg1);

SWIGIMPORT bool inworld_TTSNodeExecutionConfig_is_valid(inworld_TTSNodeExecutionConfig* carg1);

SWIGIMPORT inworld_TTSNodeExecutionConfig* inworld_TTSNodeExecutionConfig_new();

SWIGIMPORT inworld_TTSNodeExecutionConfig* inworld_TTSNodeExecutionConfig_copy(inworld_TTSNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TTSNodeExecutionConfig_delete(inworld_TTSNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TTSNodeExecutionConfig_report_to_client_set(inworld_TTSNodeExecutionConfig* carg1, bool carg2);

SWIGIMPORT bool inworld_TTSNodeExecutionConfig_report_to_client_get(inworld_TTSNodeExecutionConfig* carg1);

SWIGIMPORT void inworld_TTSNodeExecutionConfig_properties_set(inworld_TTSNodeExecutionConfig* carg1, inworld_map_string_string* carg2);

SWIGIMPORT inworld_map_string_string* inworld_TTSNodeExecutionConfig_properties_get(inworld_TTSNodeExecutionConfig* carg1);

SWIGIMPORT SWIGTYPE_p_absl__StatusOrT_std__shared_ptrT_inworld__graphs__DataStreamT_inworld__graphs__TTSOutput_t_t_t* inworld_TTSNode_Process(inworld_TTSNode* carg1, inworld_ProcessContext* carg2, SWIGTYPE_std__shared_ptrT_std__variantT_inworld__graphs__Text_inworld__graphs__DataStreamT_std__string_t_inworld__graphs__TTSRequest_t_t* carg3);

SWIGIMPORT bool inworld_TTSNode_is_valid(inworld_TTSNode* carg1);

SWIGIMPORT inworld_StatusOr_SharedPtr_TTSNode* inworld_TTSNode_Create(const char * carg1, inworld_TTSNodeExecutionConfig* carg2);

SWIGIMPORT inworld_TTSNode* inworld_TTSNode_copy(inworld_TTSNode* carg1);

SWIGIMPORT void inworld_TTSNode_delete(inworld_TTSNode* carg1);

SWIGIMPORT const char * inworld_TTSNode_id(inworld_TTSNode* carg1);

SWIGIMPORT inworld_MemoryState* inworld_MemoryState_new();

SWIGIMPORT inworld_MemoryState* inworld_MemoryState_new_inworld_MemorySnapshot(inworld_MemorySnapshot* carg1);

SWIGIMPORT inworld_MemorySnapshot* inworld_MemoryState_memory_snapshot(inworld_MemoryState* carg1);

SWIGIMPORT bool inworld_MemoryState_is_valid(inworld_MemoryState* carg1);

SWIGIMPORT const char * inworld_MemoryState_GetJson(inworld_MemoryState* carg1);

SWIGIMPORT inworld_MemoryState* inworld_MemoryState_copy(inworld_MemoryState* carg1);

SWIGIMPORT void inworld_MemoryState_delete(inworld_MemoryState* carg1);

SWIGIMPORT const char * inworld_MemoryState_ToString(inworld_MemoryState* carg1);

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus


#include <string>

namespace inworld {

class Status;
class StatusOr_opaque;
class StatusOr_int;
class StatusOr_string;
class StatusOr_vector_string;
class StatusOr_vector_float;
class StatusOr_vector_vector_float;
class StatusOr_AudioChunk;
class StatusOr_Content;
class StatusOr_KnowledgeCollection;
class StatusOr_MemorySnapshot;
class StatusOr_CheckSafetyResponse;
class StatusOr_SilenceIntervals;
class StatusOr_vector_CompiledIntent;
class StatusOr_vector_IntentMatch;
class StatusOr_vector_EntityMatch;
class StatusOr_vector_PhraseMatch;
class StatusOr_LLMInterface;
class StatusOr_LLMRouting;
class StatusOr_STTInterface;
class StatusOr_StreamingSTTInterface;
class StatusOr_TTSInterface;
class StatusOr_VADInterface;
class StatusOr_AECFilterInterface;
class StatusOr_IntentCompilerInterface;
class StatusOr_IntentMatcherInterface;
class StatusOr_KeywordMatcherInterface;
class StatusOr_KeywordMatcherResponse;
class StatusOr_KnowledgeInterface;
class StatusOr_KnowledgeRetrieverInterface;
class StatusOr_MemoryInterface;
class StatusOr_SafetyCheckerInterface;
class StatusOr_TextEmbedderInterface;
class StatusOr_EmojiRemover;
class StatusOr_SentenceStream;
class StatusOr_SubstringRemover;
class StatusOr_TextInBracketsRemover;
class StatusOr_ContentToStringStream;
class StatusOr_NERInterface;
class StatusOr_CreationContext;
class StatusOr_MCPClientInterface;
class ComponentStore;
class CreationContext;
class ComponentRegistry;
enum class StatusCode  {
  kOk = 0,
  kCancelled = 1,
  kUnknown = 2,
  kInvalidArgument = 3,
  kDeadlineExceeded = 4,
  kNotFound = 5,
  kAlreadyExists = 6,
  kPermissionDenied = 7,
  kResourceExhausted = 8,
  kFailedPrecondition = 9,
  kAborted = 10,
  kOutOfRange = 11,
  kUnimplemented = 12,
  kInternal = 13,
  kUnavailable = 14,
  kDataLoss = 15,
  kUnauthenticated = 16,
  kDoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_ = 20
};

class vector_StatusCode;
class NodeExecutionConfig;
class StatusOr_CustomConfigWrapper;
class StatusOr_CustomExecutionConfigWrapper;
class vector_CustomConfigWrapper;
class vector_CustomExecutionConfigWrapper;
class SerializerRegistry;
class ConfigWrapperDestructor;
class CustomConfigWrapper;
class CustomExecutionConfigWrapper;
class CustomConfigThreadedSerializeExecutor;
class CustomConfigThreadedDeserializeExecutor;
class CustomExecutionConfigThreadedSerializeExecutor;
class CustomExecutionConfigThreadedDeserializeExecutor;
class InputStream_TTSOutput;
class InputStream_Content;
class InputStream_string;
class InputStream_AudioChunk;
class InputStream_BaseData;
class StatusOr_InputStream_string;
class StatusOr_InputStream_AudioChunk;
class StatusOr_InputStream_Content;
class StatusOr_InputStream_BaseData;
class StatusOr_InputStream_TTSOutput;
class BlockingStream_TTSOutput;
class BlockingStream_Content;
class BlockingStream_AudioChunk;
class BlockingStream_string;
class BlockingStream_BaseData;
class StatusOr_CustomStringStreamReadThruWrapper;
class CustomStringStreamReadThruExecutor;
class CustomStringStreamReadThruWrapper;
class ContentToStringStream;
class vector_CompiledIntent;
class vector_Device;
class vector_Event;
class vector_Intent;
class vector_IntentMatch;
class vector_KeywordMatch;
class vector_KeywordGroup;
class vector_PhraseMatch;
class vector_KnowledgeRecord;
class vector_KnowledgeCollection;
class vector_LLMRoutingConfig;
class vector_TopicThreshold;
class vector_DetectedTopic;
class vector_DictionaryRule;
class vector_Entity;
class vector_EntityMatch;
class vector_vector_float;
class vector_string;
class vector_map_string_string;
class map_string_string;
class optional_BatchProcessingOptions;
class Span;
class SpanDataEvent;
class SpanData;
enum class ExporterType  {
  kLocal,
  kRemote
};

class BatchProcessingOptions;
class TracerConfig;
enum class LogLevel  {
  kTrace,
  kDebug,
  kInfo,
  kWarn,
  kError
};

class LoggerConfig;
class MetricConfig;
class TelemetryConfig;
class TelemetryConfigBuilder;
class vector_TelemetrySpan;
class vector_SpanData;
class vector_SpanDataEvent;
class vector_Edge;
class vector_char;
class vector_float;
class TransformationStreamDestructor;
class TransformationStream_BaseData_To_string;
class TransformationStreamThreadedTransformExecutor_BaseData_To_string;
class TransformationStream_BaseData_To_Content;
class TransformationStreamThreadedTransformExecutor_BaseData_To_Content;
class TransformationStream_BaseData_To_AudioChunk;
class TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk;
class TransformationStream_BaseData_To_TTSOutput;
class TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput;
class TransformationStream_BaseData_To_BaseData;
class TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData;
class TransformationStream_string_To_Content;
class TransformationStreamThreadedTransformExecutor_string_To_Content;
class TransformationStream_string_To_AudioChunk;
class TransformationStreamThreadedTransformExecutor_string_To_AudioChunk;
class TransformationStream_string_To_TTSOutput;
class TransformationStreamThreadedTransformExecutor_string_To_TTSOutput;
class TransformationStream_string_To_BaseData;
class TransformationStreamThreadedTransformExecutor_string_To_BaseData;
class TransformationStream_string_To_string;
class TransformationStreamThreadedTransformExecutor_string_To_string;
class TransformationStream_Content_To_string;
class TransformationStreamThreadedTransformExecutor_Content_To_string;
class TransformationStream_Content_To_AudioChunk;
class TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk;
class TransformationStream_Content_To_TTSOutput;
class TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput;
class TransformationStream_Content_To_BaseData;
class TransformationStreamThreadedTransformExecutor_Content_To_BaseData;
class TransformationStream_Content_To_Content;
class TransformationStreamThreadedTransformExecutor_Content_To_Content;
class TransformationStream_AudioChunk_To_string;
class TransformationStreamThreadedTransformExecutor_AudioChunk_To_string;
class TransformationStream_AudioChunk_To_Content;
class TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content;
class TransformationStream_AudioChunk_To_TTSOutput;
class TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput;
class TransformationStream_AudioChunk_To_BaseData;
class TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData;
class TransformationStream_AudioChunk_To_AudioChunk;
class TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk;
class TransformationStream_TTSOutput_To_string;
class TransformationStreamThreadedTransformExecutor_TTSOutput_To_string;
class TransformationStream_TTSOutput_To_Content;
class TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content;
class TransformationStream_TTSOutput_To_AudioChunk;
class TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk;
class TransformationStream_TTSOutput_To_BaseData;
class TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData;
class TransformationStream_TTSOutput_To_TTSOutput;
class TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput;
class TransformationStreamThreadedFilterExecutor_BaseData;
class TransformationStreamThreadedFilterExecutor_string;
class TransformationStreamThreadedFilterExecutor_Content;
class TransformationStreamThreadedFilterExecutor_AudioChunk;
class TransformationStreamThreadedFilterExecutor_TTSOutput;
class AgentSpeech;
class AgentAction;
class Event;
class Intent;
class CompiledIntent;
class StatusOr_Language;
class Language;
enum class DeviceType  {
  kCPU,
  kCUDA,
  kMetal,
  kROCM
};

class DeviceInfo;
class Device;
class DeviceRegistry;
class ModelProperties;
class ModelInterface;
class TextEmbedderInterface;
class optional_LocalTextEmbedderConfig;
class optional_RemoteTextEmbedderConfig;
class LocalTextEmbedderConfig;
class RemoteTextEmbedderConfig;
class TextEmbedderCreationConfig;
class TextEmbedderFactory;
class optional_float;
class optional_int;
class optional_sizet;
class optional_string;
class optional_UserContext;
class AudioChunk;
class Duration;
class SpeechSynthesisPostprocessingConfig;
class SpeechSynthesisInferenceConfig;
class InworldSpeechSynthesisConfig;
class ElevenLabsSpeechSynthesisConfig;
class QueryParams;
class RequestParams;
class SpeechSynthesisConfig;
class Voice;
class TTSInterface;
class optional_Voice;
class optional_TextGenerationConfig;
class optional_ToolChoice;
class Vector_ChatMessage;
class Vector_Tool;
class optional_vector_ChatMessage;
class optional_vector_Tool;
class SpeechRecognitionConfig;
class STTInterface;
class optional_SpeechSynthesisConfig;
class optional_SpeechRecognitionConfig;
class optional_TextClassifierConfig;
class LogitBiasVector;
class StatusOr_Tools;
class Messages;
class ToolCalls;
class ContentItems;
enum class ResponseFormat  {
  kText = 1,
  kJson = 2,
  kJsonSchema = 3
};

class LogitBias;
class TextGenerationConfig;
class Tool;
class FunctionChoice;
class ToolChoice;
class ToolCall;
class ImageUrl;
class ContentItem;
class Message;
class Content;
class LLMInterface;
class optional_LocalLLMConfig;
class optional_RemoteLLMConfig;
class LocalLLMConfig;
class RemoteLLMConfig;
class LLMCreationConfig;
class LLMFactory;
class LLMRoutingHelper;
class LLMRoutingConfig;
class LLMRoutingCreationConfig;
class LLMRouting;
class KnowledgeRecord;
class KnowledgeCollection;
class RetrievalConfig;
class KnowledgeRetrieverInterface;
class File;
class FileContent;
class ParsingConfig;
class KnowledgeCompileConfig;
class KnowledgeInterface;
class optional_LocalKnowledgeConfig;
class optional_RemoteKnowledgeConfig;
class LocalKnowledgeConfig;
class RemoteKnowledgeConfig;
class KnowledgeCreationConfig;
class KnowledgeFactory;
class KnowledgeCollectionFactory;
class KnowledgeRetrieverFactory;
class optional_RollingSummaryConfig;
class optional_FlashMemoryConfig;
class optional_LongTermMemoryConfig;
class RollingSummary;
class FlashMemory;
class LongTermMemory;
class MemorySnapshot;
class RollingSummaryConfig;
class FlashMemoryConfig;
class LongTermMemoryConfig;
class MemoryUpdateConfig;
class MemoryInterface;
class MemoryFactory;
class IntentCompilerInterface;
class IntentCompilerFactory;
class optional_LlmMatcherConfig;
class optional_TextEmbedderInterface;
class optional_EmbeddingMatcherConfig;
class IntentMatch;
class EmbeddingMatcherConfig;
class LlmMatcherConfig;
class IntentMatcherConfig;
class IntentMatcherInterface;
class IntentMatcherCreationConfig;
class IntentMatcherFactory;
class KeywordGroup;
class KeywordMatch;
class KeywordMatcherResponse;
class KeywordMatcherInterface;
class KeywordMatcherFactory;
class DictionaryRule;
class Entity;
class EntityMatch;
class NERInterface;
class NERCreationConfig;
class NERFactory;
class VectorClassThreshold;
class TextClassifierResponseStatusOr;
class ClassThreshold;
class TextClassifierConfig;
class TextClassifierResponse;
class TextClassifierInterface;
class TextClassifierInterfaceSharedPtrStatusOr;
class TextClassifierCreationConfig;
class TextClassifierFactory;
enum class TopicName  {
  kPolitics,
  kSubstanceUse,
  kReligion,
  kUnconditionalSelfHarm,
  kUnconditionalSexualMinors,
  kUnconditionalHateGroup,
  kAdultSexual,
  kViolence,
  kAlcohol,
  kProfanity
};

class TopicThreshold;
class SafetyConfig;
class DetectedTopic;
class CheckSafetyResponse;
class SafetyCheckerInterface;
class SafetyCheckerCreationConfig;
class SafetyCheckerFactory;
class EmojiRemover;
class SentenceStreamCreationConfig;
class SentenceStream;
class SubstringRemover;
class TextInBracketsRemover;
class optional_LocalSTTConfig;
class optional_RemoteSTTConfig;
class optional_Language;
class LocalSTTConfig;
class RemoteSTTConfig;
class STTCreationConfig;
class STTFactory;
class StreamSpeechRecognitionConfig;
class StreamingSTTInterface;
class optional_LocalStreamingSTTConfig;
class optional_RemoteStreamingSTTConfig;
class LocalStreamingSTTConfig;
class RemoteStreamingSTTConfig;
class StreamingSTTCreationConfig;
class StreamingSTTFactory;
class optional_RemoteTTSConfig;
class LocalTTSConfig;
class RemoteTTSConfig;
class TTSCreationConfig;
class TTSFactory;
class SilenceIntervals;
class IntPair;
class VoiceActivityDetectionConfig;
class VADInterface;
class LocalVADConfig;
class VADFactory;
class AcousticEchoCancellationConfig;
class AECFilterInterface;
class LocalAECFilterConfig;
class AECFilterFactory;
class NodeExecutionTelemetryContext;
class CancellationContext;
class ProcessContext;
class vector_BaseData;
class vector_Text;
class vector_ToolCallResult;
class StatusOr_Json;
class StatusOr_LLMCompletionRequest;
class BaseData;
class Text;
class Audio;
class TTSOutput;
class PhraseMatch;
class SafetyResult;
class MatchedKeywords;
class MatchedPhrases;
class ClassificationResult;
class KnowledgeRecords;
class Error;
class MatchedIntents;
class GoalAdvancement;
class Json;
class ToolCallRequest;
class ListToolsResponse;
class LLMChatRequest;
class LLMChatResponse;
class LLMCompletionRequest;
class LLMCompletionResponse;
class ToolCallResult;
class ToolCallResponse;
class TTSRequest;
class STTRequest;
class CustomDataToJsonExecutor;
class CustomDataDestructor;
class CustomDataWrapper;
class StatusOr_BaseData;
class Node;
class TypedNodeBase;
class CustomNodeProcessExecutor;
class CustomNodeThreadedProcessExecutor;
class CustomNodeDestructor;
class CustomNodeWrapper;
class TypedNode_Text_Text;
class TypedNode_Text_Audio;
class TypedNode_BaseData_Text;
class TypedNode_TTSOutputStream_Text_DataStream_String;
class TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest;
class TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text;
class TypedNode_KnowledgeRecords_Text;
class TypedNode_Text_Variant_Text_DataStream_String;
class TypedNode_DataStream_String_Variant_Text_DataStream_String;
class TypedNode_BaseData_LLMChatRequest;
class TypedNode_Text_Variant_Audio_DataStream_AudioChunk;
class TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse;
class TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse;
class TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest;
class HashSet_String;
class HashMap_StringToHashSetString;
class Edge;
class Loop;
class HashMap_StringToNode;
class HashMap_StringToLoop;
class CompiledGraphInterface;
class DataStore;
class EdgeContext;
class StatusOr_CompiledGraphInterfacePtr;
class StatusOr_ConfigParserPtr;
class ConfigParser;
class Graph;
class EdgeConditionExecutor;
class EdgeConditionThreadedExecutor;
class EdgeWrapper;
class MCPClientInterface;
class vector_Node;
class LinearGraph;
class StatusOr_TTSOutput;
class DataStream_TTSOutput;
class DataStream_String;
class DataStream_Content;
class DataStream_AudioChunk;
class DataStream_BaseData;
class EventHistory;
class StatusOr_CustomNodeWrapper;
class CustomNodeThreadedCreateExecutor;
class HashMap_StringToString;
class BTreeMap_StringToString;
class HashMap_StringToBaseData;
class OptionalHashMapStringToBaseData;
class StatusOr_ResultItem;
class InputStream_ResultItem;
class ResultItem;
class ExecutionResult;
class UserContext;
class ExecutionContext;
class ExecutorInterface;
class StatusOr_ExecutorInterfacePtr;
class StatusOr_GraphExecutorFactoryPtr;
class Optional_ThreadPoolConfig;
class GraphManagerConfig;
class ThreadPoolConfig;
class GraphExecutorFactoryConfig;
class GraphExecutorConfig;
class GraphExecutorFactory;
class FeedbackRecorder;
class MCPHttpAuthConfig;
class ParagonApiAuthConfig;
class MCPStdioAuthConfig;
class MCPAuthConfig;
class MCPSessionCreationConfig;
class MCPClientCreationConfig;
class MCPClientFactory;
class TypedNode_MatchedPhrases;
class StatusOr_SharedPtr_EmbeddingMatcherNode;
class StatusOr_SharedPtr_MatchedPhrases;
class EmbeddingMatcherNodeCreationConfig;
class EmbeddingMatcherNodeExecutionConfig;
class EmbeddingMatcherNode;
class optional_Condition;
class Condition;
class Goal;
class StatusOr_SharedPtr_GoalAdvancementNode;
class vector_Goal;
class GoalAdvancementNodeCreationConfig;
class GoalAdvancementNodeExecutionConfig;
class GoalAdvancementNode;
class TypedNode_MatchedIntents;
class StatusOr_SharedPtr_IntentNode;
class StatusOr_SharedPtr_MatchedIntents;
class optional_TextEmbedderCreationConfig;
class optional_LLMCreationConfig;
class IntentNodeExecutionConfig;
class IntentNodeCreationConfig;
class IntentNode;
class TypedNode_MatchedKeywords;
class StatusOr_SharedPtr_KeywordMatcherNode;
class StatusOr_SharedPtr_MatchedKeywords;
class KeywordMatcherNodeCreationConfig;
class KeywordMatcherNode;
class TypedNode_KnowledgeRecords_Text_Text;
class StatusOr_SharedPtr_KnowledgeNode;
class StatusOr_SharedPtr_KnowledgeRecords;
class KnowledgeNodeCreationConfig;
class KnowledgeNodeExecutionConfig;
class KnowledgeNode;
class StatusOr_SharedPtr_LLMChatNode;
class StatusOr_SharedPtr_LLMChatResponse;
class optional_vector_LLMRoutingConfig;
class TypedNode_LLMChatResponse_VariantInput;
class StringTemplate;
class TextContent;
class ImageContent;
class ChatMessageContent;
class ChatMessage;
class LLMChatNodeExecutionConfig;
class LLMChatNode;
class StatusOr_SharedPtr_LLMCompletionNode;
class StatusOr_SharedPtr_LLMCompletionResponse;
class TypedNode_LLMCompletionResponse_VariantInput;
class LLMCompletionNodeExecutionConfig;
class LLMCompletionNode;
class TypedNode_ToolCallResponse_ToolCallRequest;
class TypedNode_ListToolsResponse_Text;
class StatusOr_SharedPtr_MCPListToolsNode;
class StatusOr_SharedPtr_MCPCallToolNode;
class StatusOr_SharedPtr_ToolCallResponse;
class MCPListToolsNodeExecutionConfig;
class MCPListToolsNode;
class MCPCallToolNodeExecutionConfig;
class MCPCallToolNode;
class TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text;
class TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text;
class StatusOr_SharedPtr_MemoryUpdateNode;
class StatusOr_SharedPtr_MemoryRetrieveNode;
class MemoryUpdateNodeCreationConfig;
class MemoryRetrieveNodeCreationConfig;
class MemoryRetrieveNodeExecutionConfig;
class MemoryUpdateNode;
class MemoryRetrieveNode;
class StatusOr_SharedPtr_RandomCannedTextNode;
class RandomCannedTextNodeExecutionConfig;
class RandomCannedTextNode;
class TypedNode_SafetyResult;
class StatusOr_SharedPtr_SafetyCheckerNode;
class StatusOr_SharedPtr_SafetyResult;
class optional_SafetyConfig;
class SafetyCheckerNodeCreationConfig;
class SafetyCheckerNodeExecutionConfig;
class SafetyCheckerNode;
class StatusOr_SharedPtr_STTNode;
class STTNodeExecutionConfig;
class STTNode;
class StatusOr_SharedPtr_TextAggregatorNode;
class TextAggregatorNode;
class StatusOr_SharedPtr_TextChunkingNode;
class TextChunkingNodeExecutionConfig;
class TextChunkingNode;
class TypedNode_ClassificationResult;
class StatusOr_SharedPtr_TextClassifierNode;
class StatusOr_SharedPtr_ClassificationResult;
class TextClassifierNodeCreationConfig;
class TextClassifierNodeExecutionConfig;
class TextClassifierNode;
class StatusOr_SharedPtr_TTSNode;
class TTSNodeExecutionConfig;
class TTSNode;
class MemoryState;

class Status {
public:
  bool ok() const;
  static Status inworld_absl_Status_createStatus__SWIG(StatusCode code, std::string const& arg2);
  std::string ToString() const;
  Status();
  Status(Status const & other);
  ~Status() {
    if (swig_owns_self_)
      inworld_Status_delete(swig_self_);
  }

  explicit Status(SwigObj_inworld_Status* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Status& operator=(Status const&) = delete;
  Status(Status&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Status& operator=(Status&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Status_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Status* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Status* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_opaque {
public:
  StatusOr_opaque();
  StatusOr_opaque(void ** value);
  StatusOr_opaque(Status const & status);
  bool ok() const;
  Status status() const;
  void * value() const;
  StatusOr_opaque(StatusOr_opaque const & other);
  ~StatusOr_opaque() {
    if (swig_owns_self_)
      inworld_StatusOr_opaque_delete(swig_self_);
  }

  explicit StatusOr_opaque(SwigObj_inworld_StatusOr_opaque* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_opaque& operator=(StatusOr_opaque const&) = delete;
  StatusOr_opaque(StatusOr_opaque&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_opaque& operator=(StatusOr_opaque&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_opaque_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_opaque* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_opaque* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_int {
public:
  StatusOr_int();
  StatusOr_int(int value);
  StatusOr_int(Status const & status);
  bool ok() const;
  Status status() const;
  int value() const;
  StatusOr_int(StatusOr_int const & other);
  ~StatusOr_int() {
    if (swig_owns_self_)
      inworld_StatusOr_int_delete(swig_self_);
  }

  explicit StatusOr_int(SwigObj_inworld_StatusOr_int* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_int& operator=(StatusOr_int const&) = delete;
  StatusOr_int(StatusOr_int&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_int& operator=(StatusOr_int&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_int_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_int* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_int* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_string {
public:
  StatusOr_string();
  StatusOr_string(std::string const& value);
  StatusOr_string(Status const & status);
  bool ok() const;
  Status status() const;
  std::string value() const;
  StatusOr_string(StatusOr_string const & other);
  ~StatusOr_string() {
    if (swig_owns_self_)
      inworld_StatusOr_string_delete(swig_self_);
  }

  explicit StatusOr_string(SwigObj_inworld_StatusOr_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_string& operator=(StatusOr_string const&) = delete;
  StatusOr_string(StatusOr_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_string& operator=(StatusOr_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_string* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_vector_string {
public:
  StatusOr_vector_string();
  StatusOr_vector_string(vector_string const & value);
  StatusOr_vector_string(Status const & status);
  bool ok() const;
  Status status() const;
  vector_string value() const;
  StatusOr_vector_string(StatusOr_vector_string const & other);
  ~StatusOr_vector_string() {
    if (swig_owns_self_)
      inworld_StatusOr_vector_string_delete(swig_self_);
  }

  explicit StatusOr_vector_string(SwigObj_inworld_StatusOr_vector_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_vector_string& operator=(StatusOr_vector_string const&) = delete;
  StatusOr_vector_string(StatusOr_vector_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_vector_string& operator=(StatusOr_vector_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_vector_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_vector_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_vector_string* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_vector_float {
public:
  StatusOr_vector_float();
  StatusOr_vector_float(vector_float const & value);
  StatusOr_vector_float(Status const & status);
  bool ok() const;
  Status status() const;
  vector_float value() const;
  StatusOr_vector_float(StatusOr_vector_float const & other);
  ~StatusOr_vector_float() {
    if (swig_owns_self_)
      inworld_StatusOr_vector_float_delete(swig_self_);
  }

  explicit StatusOr_vector_float(SwigObj_inworld_StatusOr_vector_float* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_vector_float& operator=(StatusOr_vector_float const&) = delete;
  StatusOr_vector_float(StatusOr_vector_float&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_vector_float& operator=(StatusOr_vector_float&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_vector_float_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_vector_float* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_vector_float* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_vector_vector_float {
public:
  StatusOr_vector_vector_float();
  StatusOr_vector_vector_float(vector_vector_float const & value);
  StatusOr_vector_vector_float(Status const & status);
  bool ok() const;
  Status status() const;
  vector_vector_float value() const;
  StatusOr_vector_vector_float(StatusOr_vector_vector_float const & other);
  ~StatusOr_vector_vector_float() {
    if (swig_owns_self_)
      inworld_StatusOr_vector_vector_float_delete(swig_self_);
  }

  explicit StatusOr_vector_vector_float(SwigObj_inworld_StatusOr_vector_vector_float* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_vector_vector_float& operator=(StatusOr_vector_vector_float const&) = delete;
  StatusOr_vector_vector_float(StatusOr_vector_vector_float&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_vector_vector_float& operator=(StatusOr_vector_vector_float&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_vector_vector_float_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_vector_vector_float* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_vector_vector_float* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_AudioChunk {
public:
  StatusOr_AudioChunk();
  StatusOr_AudioChunk(AudioChunk const & value);
  StatusOr_AudioChunk(Status const & status);
  bool ok() const;
  Status status() const;
  AudioChunk value() const;
  StatusOr_AudioChunk(StatusOr_AudioChunk const & other);
  ~StatusOr_AudioChunk() {
    if (swig_owns_self_)
      inworld_StatusOr_AudioChunk_delete(swig_self_);
  }

  explicit StatusOr_AudioChunk(SwigObj_inworld_StatusOr_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_AudioChunk& operator=(StatusOr_AudioChunk const&) = delete;
  StatusOr_AudioChunk(StatusOr_AudioChunk&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_AudioChunk& operator=(StatusOr_AudioChunk&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_AudioChunk_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_AudioChunk* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_AudioChunk* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_Content {
public:
  StatusOr_Content();
  StatusOr_Content(Content const & value);
  StatusOr_Content(Status const & status);
  bool ok() const;
  Status status() const;
  Content value() const;
  StatusOr_Content(StatusOr_Content const & other);
  ~StatusOr_Content() {
    if (swig_owns_self_)
      inworld_StatusOr_Content_delete(swig_self_);
  }

  explicit StatusOr_Content(SwigObj_inworld_StatusOr_Content* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_Content& operator=(StatusOr_Content const&) = delete;
  StatusOr_Content(StatusOr_Content&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_Content& operator=(StatusOr_Content&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_Content_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_Content* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_Content* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_KnowledgeCollection {
public:
  StatusOr_KnowledgeCollection();
  StatusOr_KnowledgeCollection(KnowledgeCollection const & value);
  StatusOr_KnowledgeCollection(Status const & status);
  bool ok() const;
  Status status() const;
  KnowledgeCollection value() const;
  StatusOr_KnowledgeCollection(StatusOr_KnowledgeCollection const & other);
  ~StatusOr_KnowledgeCollection() {
    if (swig_owns_self_)
      inworld_StatusOr_KnowledgeCollection_delete(swig_self_);
  }

  explicit StatusOr_KnowledgeCollection(SwigObj_inworld_StatusOr_KnowledgeCollection* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_KnowledgeCollection& operator=(StatusOr_KnowledgeCollection const&) = delete;
  StatusOr_KnowledgeCollection(StatusOr_KnowledgeCollection&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_KnowledgeCollection& operator=(StatusOr_KnowledgeCollection&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_KnowledgeCollection_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_KnowledgeCollection* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_KnowledgeCollection* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_MemorySnapshot {
public:
  StatusOr_MemorySnapshot();
  StatusOr_MemorySnapshot(MemorySnapshot const & value);
  StatusOr_MemorySnapshot(Status const & status);
  bool ok() const;
  Status status() const;
  MemorySnapshot value() const;
  StatusOr_MemorySnapshot(StatusOr_MemorySnapshot const & other);
  ~StatusOr_MemorySnapshot() {
    if (swig_owns_self_)
      inworld_StatusOr_MemorySnapshot_delete(swig_self_);
  }

  explicit StatusOr_MemorySnapshot(SwigObj_inworld_StatusOr_MemorySnapshot* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_MemorySnapshot& operator=(StatusOr_MemorySnapshot const&) = delete;
  StatusOr_MemorySnapshot(StatusOr_MemorySnapshot&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_MemorySnapshot& operator=(StatusOr_MemorySnapshot&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_MemorySnapshot_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_MemorySnapshot* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_MemorySnapshot* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_CheckSafetyResponse {
public:
  StatusOr_CheckSafetyResponse();
  StatusOr_CheckSafetyResponse(CheckSafetyResponse const & value);
  StatusOr_CheckSafetyResponse(Status const & status);
  bool ok() const;
  Status status() const;
  CheckSafetyResponse value() const;
  StatusOr_CheckSafetyResponse(StatusOr_CheckSafetyResponse const & other);
  ~StatusOr_CheckSafetyResponse() {
    if (swig_owns_self_)
      inworld_StatusOr_CheckSafetyResponse_delete(swig_self_);
  }

  explicit StatusOr_CheckSafetyResponse(SwigObj_inworld_StatusOr_CheckSafetyResponse* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_CheckSafetyResponse& operator=(StatusOr_CheckSafetyResponse const&) = delete;
  StatusOr_CheckSafetyResponse(StatusOr_CheckSafetyResponse&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_CheckSafetyResponse& operator=(StatusOr_CheckSafetyResponse&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_CheckSafetyResponse_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_CheckSafetyResponse* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_CheckSafetyResponse* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SilenceIntervals {
public:
  StatusOr_SilenceIntervals();
  StatusOr_SilenceIntervals(SilenceIntervals const & value);
  StatusOr_SilenceIntervals(Status const & status);
  bool ok() const;
  Status status() const;
  SilenceIntervals value() const;
  StatusOr_SilenceIntervals(StatusOr_SilenceIntervals const & other);
  ~StatusOr_SilenceIntervals() {
    if (swig_owns_self_)
      inworld_StatusOr_SilenceIntervals_delete(swig_self_);
  }

  explicit StatusOr_SilenceIntervals(SwigObj_inworld_StatusOr_SilenceIntervals* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SilenceIntervals& operator=(StatusOr_SilenceIntervals const&) = delete;
  StatusOr_SilenceIntervals(StatusOr_SilenceIntervals&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SilenceIntervals& operator=(StatusOr_SilenceIntervals&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SilenceIntervals_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SilenceIntervals* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SilenceIntervals* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_vector_CompiledIntent {
public:
  StatusOr_vector_CompiledIntent();
  StatusOr_vector_CompiledIntent(vector_CompiledIntent const & value);
  StatusOr_vector_CompiledIntent(Status const & status);
  bool ok() const;
  Status status() const;
  vector_CompiledIntent value() const;
  StatusOr_vector_CompiledIntent(StatusOr_vector_CompiledIntent const & other);
  ~StatusOr_vector_CompiledIntent() {
    if (swig_owns_self_)
      inworld_StatusOr_vector_CompiledIntent_delete(swig_self_);
  }

  explicit StatusOr_vector_CompiledIntent(SwigObj_inworld_StatusOr_vector_CompiledIntent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_vector_CompiledIntent& operator=(StatusOr_vector_CompiledIntent const&) = delete;
  StatusOr_vector_CompiledIntent(StatusOr_vector_CompiledIntent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_vector_CompiledIntent& operator=(StatusOr_vector_CompiledIntent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_vector_CompiledIntent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_vector_CompiledIntent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_vector_CompiledIntent* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_vector_IntentMatch {
public:
  StatusOr_vector_IntentMatch();
  StatusOr_vector_IntentMatch(vector_IntentMatch const & value);
  StatusOr_vector_IntentMatch(Status const & status);
  bool ok() const;
  Status status() const;
  vector_IntentMatch value() const;
  StatusOr_vector_IntentMatch(StatusOr_vector_IntentMatch const & other);
  ~StatusOr_vector_IntentMatch() {
    if (swig_owns_self_)
      inworld_StatusOr_vector_IntentMatch_delete(swig_self_);
  }

  explicit StatusOr_vector_IntentMatch(SwigObj_inworld_StatusOr_vector_IntentMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_vector_IntentMatch& operator=(StatusOr_vector_IntentMatch const&) = delete;
  StatusOr_vector_IntentMatch(StatusOr_vector_IntentMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_vector_IntentMatch& operator=(StatusOr_vector_IntentMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_vector_IntentMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_vector_IntentMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_vector_IntentMatch* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_vector_EntityMatch {
public:
  StatusOr_vector_EntityMatch();
  StatusOr_vector_EntityMatch(vector_EntityMatch const & value);
  StatusOr_vector_EntityMatch(Status const & status);
  bool ok() const;
  Status status() const;
  vector_EntityMatch value() const;
  StatusOr_vector_EntityMatch(StatusOr_vector_EntityMatch const & other);
  ~StatusOr_vector_EntityMatch() {
    if (swig_owns_self_)
      inworld_StatusOr_vector_EntityMatch_delete(swig_self_);
  }

  explicit StatusOr_vector_EntityMatch(SwigObj_inworld_StatusOr_vector_EntityMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_vector_EntityMatch& operator=(StatusOr_vector_EntityMatch const&) = delete;
  StatusOr_vector_EntityMatch(StatusOr_vector_EntityMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_vector_EntityMatch& operator=(StatusOr_vector_EntityMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_vector_EntityMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_vector_EntityMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_vector_EntityMatch* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_vector_PhraseMatch {
public:
  StatusOr_vector_PhraseMatch();
  StatusOr_vector_PhraseMatch(vector_PhraseMatch const & value);
  StatusOr_vector_PhraseMatch(Status const & status);
  bool ok() const;
  Status status() const;
  vector_PhraseMatch value() const;
  StatusOr_vector_PhraseMatch(StatusOr_vector_PhraseMatch const & other);
  ~StatusOr_vector_PhraseMatch() {
    if (swig_owns_self_)
      inworld_StatusOr_vector_PhraseMatch_delete(swig_self_);
  }

  explicit StatusOr_vector_PhraseMatch(SwigObj_inworld_StatusOr_vector_PhraseMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_vector_PhraseMatch& operator=(StatusOr_vector_PhraseMatch const&) = delete;
  StatusOr_vector_PhraseMatch(StatusOr_vector_PhraseMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_vector_PhraseMatch& operator=(StatusOr_vector_PhraseMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_vector_PhraseMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_vector_PhraseMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_vector_PhraseMatch* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_LLMInterface {
public:
  StatusOr_LLMInterface();
  StatusOr_LLMInterface(LLMInterface const& value);
  StatusOr_LLMInterface(Status const & status);
  bool ok() const;
  Status status() const;
  LLMInterface value() const;
  StatusOr_LLMInterface(StatusOr_LLMInterface const & other);
  ~StatusOr_LLMInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_LLMInterface_delete(swig_self_);
  }

  explicit StatusOr_LLMInterface(SwigObj_inworld_StatusOr_LLMInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_LLMInterface& operator=(StatusOr_LLMInterface const&) = delete;
  StatusOr_LLMInterface(StatusOr_LLMInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_LLMInterface& operator=(StatusOr_LLMInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_LLMInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_LLMInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_LLMInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_LLMRouting {
public:
  StatusOr_LLMRouting();
  StatusOr_LLMRouting(LLMRouting const& value);
  StatusOr_LLMRouting(Status const & status);
  bool ok() const;
  Status status() const;
  LLMRouting value() const;
  StatusOr_LLMRouting(StatusOr_LLMRouting const & other);
  ~StatusOr_LLMRouting() {
    if (swig_owns_self_)
      inworld_StatusOr_LLMRouting_delete(swig_self_);
  }

  explicit StatusOr_LLMRouting(SwigObj_inworld_StatusOr_LLMRouting* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_LLMRouting& operator=(StatusOr_LLMRouting const&) = delete;
  StatusOr_LLMRouting(StatusOr_LLMRouting&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_LLMRouting& operator=(StatusOr_LLMRouting&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_LLMRouting_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_LLMRouting* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_LLMRouting* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_STTInterface {
public:
  StatusOr_STTInterface();
  StatusOr_STTInterface(STTInterface const& value);
  StatusOr_STTInterface(Status const & status);
  bool ok() const;
  Status status() const;
  STTInterface value() const;
  StatusOr_STTInterface(StatusOr_STTInterface const & other);
  ~StatusOr_STTInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_STTInterface_delete(swig_self_);
  }

  explicit StatusOr_STTInterface(SwigObj_inworld_StatusOr_STTInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_STTInterface& operator=(StatusOr_STTInterface const&) = delete;
  StatusOr_STTInterface(StatusOr_STTInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_STTInterface& operator=(StatusOr_STTInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_STTInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_STTInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_STTInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_StreamingSTTInterface {
public:
  StatusOr_StreamingSTTInterface();
  StatusOr_StreamingSTTInterface(StreamingSTTInterface const& value);
  StatusOr_StreamingSTTInterface(Status const & status);
  bool ok() const;
  Status status() const;
  StreamingSTTInterface value() const;
  StatusOr_StreamingSTTInterface(StatusOr_StreamingSTTInterface const & other);
  ~StatusOr_StreamingSTTInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_StreamingSTTInterface_delete(swig_self_);
  }

  explicit StatusOr_StreamingSTTInterface(SwigObj_inworld_StatusOr_StreamingSTTInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_StreamingSTTInterface& operator=(StatusOr_StreamingSTTInterface const&) = delete;
  StatusOr_StreamingSTTInterface(StatusOr_StreamingSTTInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_StreamingSTTInterface& operator=(StatusOr_StreamingSTTInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_StreamingSTTInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_StreamingSTTInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_StreamingSTTInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_TTSInterface {
public:
  StatusOr_TTSInterface();
  StatusOr_TTSInterface(TTSInterface const& value);
  StatusOr_TTSInterface(Status const & status);
  bool ok() const;
  Status status() const;
  TTSInterface value() const;
  StatusOr_TTSInterface(StatusOr_TTSInterface const & other);
  ~StatusOr_TTSInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_TTSInterface_delete(swig_self_);
  }

  explicit StatusOr_TTSInterface(SwigObj_inworld_StatusOr_TTSInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_TTSInterface& operator=(StatusOr_TTSInterface const&) = delete;
  StatusOr_TTSInterface(StatusOr_TTSInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_TTSInterface& operator=(StatusOr_TTSInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_TTSInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_TTSInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_TTSInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_VADInterface {
public:
  StatusOr_VADInterface();
  StatusOr_VADInterface(VADInterface const& value);
  StatusOr_VADInterface(Status const & status);
  bool ok() const;
  Status status() const;
  VADInterface value() const;
  StatusOr_VADInterface(StatusOr_VADInterface const & other);
  ~StatusOr_VADInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_VADInterface_delete(swig_self_);
  }

  explicit StatusOr_VADInterface(SwigObj_inworld_StatusOr_VADInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_VADInterface& operator=(StatusOr_VADInterface const&) = delete;
  StatusOr_VADInterface(StatusOr_VADInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_VADInterface& operator=(StatusOr_VADInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_VADInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_VADInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_VADInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_AECFilterInterface {
public:
  StatusOr_AECFilterInterface();
  StatusOr_AECFilterInterface(AECFilterInterface const& value);
  StatusOr_AECFilterInterface(Status const & status);
  bool ok() const;
  Status status() const;
  AECFilterInterface value() const;
  StatusOr_AECFilterInterface(StatusOr_AECFilterInterface const & other);
  ~StatusOr_AECFilterInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_AECFilterInterface_delete(swig_self_);
  }

  explicit StatusOr_AECFilterInterface(SwigObj_inworld_StatusOr_AECFilterInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_AECFilterInterface& operator=(StatusOr_AECFilterInterface const&) = delete;
  StatusOr_AECFilterInterface(StatusOr_AECFilterInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_AECFilterInterface& operator=(StatusOr_AECFilterInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_AECFilterInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_AECFilterInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_AECFilterInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_IntentCompilerInterface {
public:
  StatusOr_IntentCompilerInterface();
  StatusOr_IntentCompilerInterface(IntentCompilerInterface const& value);
  StatusOr_IntentCompilerInterface(Status const & status);
  bool ok() const;
  Status status() const;
  IntentCompilerInterface value() const;
  StatusOr_IntentCompilerInterface(StatusOr_IntentCompilerInterface const & other);
  ~StatusOr_IntentCompilerInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_IntentCompilerInterface_delete(swig_self_);
  }

  explicit StatusOr_IntentCompilerInterface(SwigObj_inworld_StatusOr_IntentCompilerInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_IntentCompilerInterface& operator=(StatusOr_IntentCompilerInterface const&) = delete;
  StatusOr_IntentCompilerInterface(StatusOr_IntentCompilerInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_IntentCompilerInterface& operator=(StatusOr_IntentCompilerInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_IntentCompilerInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_IntentCompilerInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_IntentCompilerInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_IntentMatcherInterface {
public:
  StatusOr_IntentMatcherInterface();
  StatusOr_IntentMatcherInterface(IntentMatcherInterface const& value);
  StatusOr_IntentMatcherInterface(Status const & status);
  bool ok() const;
  Status status() const;
  IntentMatcherInterface value() const;
  StatusOr_IntentMatcherInterface(StatusOr_IntentMatcherInterface const & other);
  ~StatusOr_IntentMatcherInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_IntentMatcherInterface_delete(swig_self_);
  }

  explicit StatusOr_IntentMatcherInterface(SwigObj_inworld_StatusOr_IntentMatcherInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_IntentMatcherInterface& operator=(StatusOr_IntentMatcherInterface const&) = delete;
  StatusOr_IntentMatcherInterface(StatusOr_IntentMatcherInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_IntentMatcherInterface& operator=(StatusOr_IntentMatcherInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_IntentMatcherInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_IntentMatcherInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_IntentMatcherInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_KeywordMatcherInterface {
public:
  StatusOr_KeywordMatcherInterface();
  StatusOr_KeywordMatcherInterface(KeywordMatcherInterface const& value);
  StatusOr_KeywordMatcherInterface(Status const & status);
  bool ok() const;
  Status status() const;
  KeywordMatcherInterface value() const;
  StatusOr_KeywordMatcherInterface(StatusOr_KeywordMatcherInterface const & other);
  ~StatusOr_KeywordMatcherInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_KeywordMatcherInterface_delete(swig_self_);
  }

  explicit StatusOr_KeywordMatcherInterface(SwigObj_inworld_StatusOr_KeywordMatcherInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_KeywordMatcherInterface& operator=(StatusOr_KeywordMatcherInterface const&) = delete;
  StatusOr_KeywordMatcherInterface(StatusOr_KeywordMatcherInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_KeywordMatcherInterface& operator=(StatusOr_KeywordMatcherInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_KeywordMatcherInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_KeywordMatcherInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_KeywordMatcherInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_KeywordMatcherResponse {
public:
  StatusOr_KeywordMatcherResponse();
  StatusOr_KeywordMatcherResponse(KeywordMatcherResponse const & value);
  StatusOr_KeywordMatcherResponse(Status const & status);
  bool ok() const;
  Status status() const;
  KeywordMatcherResponse value() const;
  StatusOr_KeywordMatcherResponse(StatusOr_KeywordMatcherResponse const & other);
  ~StatusOr_KeywordMatcherResponse() {
    if (swig_owns_self_)
      inworld_StatusOr_KeywordMatcherResponse_delete(swig_self_);
  }

  explicit StatusOr_KeywordMatcherResponse(SwigObj_inworld_StatusOr_KeywordMatcherResponse* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_KeywordMatcherResponse& operator=(StatusOr_KeywordMatcherResponse const&) = delete;
  StatusOr_KeywordMatcherResponse(StatusOr_KeywordMatcherResponse&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_KeywordMatcherResponse& operator=(StatusOr_KeywordMatcherResponse&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_KeywordMatcherResponse_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_KeywordMatcherResponse* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_KeywordMatcherResponse* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_KnowledgeInterface {
public:
  StatusOr_KnowledgeInterface();
  StatusOr_KnowledgeInterface(KnowledgeInterface const& value);
  StatusOr_KnowledgeInterface(Status const & status);
  bool ok() const;
  Status status() const;
  KnowledgeInterface value() const;
  StatusOr_KnowledgeInterface(StatusOr_KnowledgeInterface const & other);
  ~StatusOr_KnowledgeInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_KnowledgeInterface_delete(swig_self_);
  }

  explicit StatusOr_KnowledgeInterface(SwigObj_inworld_StatusOr_KnowledgeInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_KnowledgeInterface& operator=(StatusOr_KnowledgeInterface const&) = delete;
  StatusOr_KnowledgeInterface(StatusOr_KnowledgeInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_KnowledgeInterface& operator=(StatusOr_KnowledgeInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_KnowledgeInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_KnowledgeInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_KnowledgeInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_KnowledgeRetrieverInterface {
public:
  StatusOr_KnowledgeRetrieverInterface();
  StatusOr_KnowledgeRetrieverInterface(KnowledgeRetrieverInterface const& value);
  StatusOr_KnowledgeRetrieverInterface(Status const & status);
  bool ok() const;
  Status status() const;
  KnowledgeRetrieverInterface value() const;
  StatusOr_KnowledgeRetrieverInterface(StatusOr_KnowledgeRetrieverInterface const & other);
  ~StatusOr_KnowledgeRetrieverInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_KnowledgeRetrieverInterface_delete(swig_self_);
  }

  explicit StatusOr_KnowledgeRetrieverInterface(SwigObj_inworld_StatusOr_KnowledgeRetrieverInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_KnowledgeRetrieverInterface& operator=(StatusOr_KnowledgeRetrieverInterface const&) = delete;
  StatusOr_KnowledgeRetrieverInterface(StatusOr_KnowledgeRetrieverInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_KnowledgeRetrieverInterface& operator=(StatusOr_KnowledgeRetrieverInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_KnowledgeRetrieverInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_KnowledgeRetrieverInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_KnowledgeRetrieverInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_MemoryInterface {
public:
  StatusOr_MemoryInterface();
  StatusOr_MemoryInterface(MemoryInterface const& value);
  StatusOr_MemoryInterface(Status const & status);
  bool ok() const;
  Status status() const;
  MemoryInterface value() const;
  StatusOr_MemoryInterface(StatusOr_MemoryInterface const & other);
  ~StatusOr_MemoryInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_MemoryInterface_delete(swig_self_);
  }

  explicit StatusOr_MemoryInterface(SwigObj_inworld_StatusOr_MemoryInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_MemoryInterface& operator=(StatusOr_MemoryInterface const&) = delete;
  StatusOr_MemoryInterface(StatusOr_MemoryInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_MemoryInterface& operator=(StatusOr_MemoryInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_MemoryInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_MemoryInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_MemoryInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SafetyCheckerInterface {
public:
  StatusOr_SafetyCheckerInterface();
  StatusOr_SafetyCheckerInterface(SafetyCheckerInterface const& value);
  StatusOr_SafetyCheckerInterface(Status const & status);
  bool ok() const;
  Status status() const;
  SafetyCheckerInterface value() const;
  StatusOr_SafetyCheckerInterface(StatusOr_SafetyCheckerInterface const & other);
  ~StatusOr_SafetyCheckerInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_SafetyCheckerInterface_delete(swig_self_);
  }

  explicit StatusOr_SafetyCheckerInterface(SwigObj_inworld_StatusOr_SafetyCheckerInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SafetyCheckerInterface& operator=(StatusOr_SafetyCheckerInterface const&) = delete;
  StatusOr_SafetyCheckerInterface(StatusOr_SafetyCheckerInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SafetyCheckerInterface& operator=(StatusOr_SafetyCheckerInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SafetyCheckerInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SafetyCheckerInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SafetyCheckerInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_TextEmbedderInterface {
public:
  StatusOr_TextEmbedderInterface();
  StatusOr_TextEmbedderInterface(TextEmbedderInterface const& value);
  StatusOr_TextEmbedderInterface(Status const & status);
  bool ok() const;
  Status status() const;
  TextEmbedderInterface value() const;
  StatusOr_TextEmbedderInterface(StatusOr_TextEmbedderInterface const & other);
  ~StatusOr_TextEmbedderInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_TextEmbedderInterface_delete(swig_self_);
  }

  explicit StatusOr_TextEmbedderInterface(SwigObj_inworld_StatusOr_TextEmbedderInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_TextEmbedderInterface& operator=(StatusOr_TextEmbedderInterface const&) = delete;
  StatusOr_TextEmbedderInterface(StatusOr_TextEmbedderInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_TextEmbedderInterface& operator=(StatusOr_TextEmbedderInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_TextEmbedderInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_TextEmbedderInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_TextEmbedderInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_EmojiRemover {
public:
  StatusOr_EmojiRemover();
  StatusOr_EmojiRemover(EmojiRemover const& value);
  StatusOr_EmojiRemover(Status const & status);
  bool ok() const;
  Status status() const;
  EmojiRemover value() const;
  StatusOr_EmojiRemover(StatusOr_EmojiRemover const & other);
  ~StatusOr_EmojiRemover() {
    if (swig_owns_self_)
      inworld_StatusOr_EmojiRemover_delete(swig_self_);
  }

  explicit StatusOr_EmojiRemover(SwigObj_inworld_StatusOr_EmojiRemover* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_EmojiRemover& operator=(StatusOr_EmojiRemover const&) = delete;
  StatusOr_EmojiRemover(StatusOr_EmojiRemover&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_EmojiRemover& operator=(StatusOr_EmojiRemover&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_EmojiRemover_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_EmojiRemover* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_EmojiRemover* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SentenceStream {
public:
  StatusOr_SentenceStream();
  StatusOr_SentenceStream(SentenceStream const& value);
  StatusOr_SentenceStream(Status const & status);
  bool ok() const;
  Status status() const;
  SentenceStream value() const;
  StatusOr_SentenceStream(StatusOr_SentenceStream const & other);
  ~StatusOr_SentenceStream() {
    if (swig_owns_self_)
      inworld_StatusOr_SentenceStream_delete(swig_self_);
  }

  explicit StatusOr_SentenceStream(SwigObj_inworld_StatusOr_SentenceStream* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SentenceStream& operator=(StatusOr_SentenceStream const&) = delete;
  StatusOr_SentenceStream(StatusOr_SentenceStream&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SentenceStream& operator=(StatusOr_SentenceStream&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SentenceStream_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SentenceStream* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SentenceStream* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SubstringRemover {
public:
  StatusOr_SubstringRemover();
  StatusOr_SubstringRemover(SubstringRemover const& value);
  StatusOr_SubstringRemover(Status const & status);
  bool ok() const;
  Status status() const;
  SubstringRemover value() const;
  StatusOr_SubstringRemover(StatusOr_SubstringRemover const & other);
  ~StatusOr_SubstringRemover() {
    if (swig_owns_self_)
      inworld_StatusOr_SubstringRemover_delete(swig_self_);
  }

  explicit StatusOr_SubstringRemover(SwigObj_inworld_StatusOr_SubstringRemover* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SubstringRemover& operator=(StatusOr_SubstringRemover const&) = delete;
  StatusOr_SubstringRemover(StatusOr_SubstringRemover&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SubstringRemover& operator=(StatusOr_SubstringRemover&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SubstringRemover_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SubstringRemover* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SubstringRemover* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_TextInBracketsRemover {
public:
  StatusOr_TextInBracketsRemover();
  StatusOr_TextInBracketsRemover(TextInBracketsRemover const& value);
  StatusOr_TextInBracketsRemover(Status const & status);
  bool ok() const;
  Status status() const;
  TextInBracketsRemover value() const;
  StatusOr_TextInBracketsRemover(StatusOr_TextInBracketsRemover const & other);
  ~StatusOr_TextInBracketsRemover() {
    if (swig_owns_self_)
      inworld_StatusOr_TextInBracketsRemover_delete(swig_self_);
  }

  explicit StatusOr_TextInBracketsRemover(SwigObj_inworld_StatusOr_TextInBracketsRemover* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_TextInBracketsRemover& operator=(StatusOr_TextInBracketsRemover const&) = delete;
  StatusOr_TextInBracketsRemover(StatusOr_TextInBracketsRemover&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_TextInBracketsRemover& operator=(StatusOr_TextInBracketsRemover&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_TextInBracketsRemover_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_TextInBracketsRemover* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_TextInBracketsRemover* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_ContentToStringStream {
public:
  StatusOr_ContentToStringStream();
  StatusOr_ContentToStringStream(ContentToStringStream const& value);
  StatusOr_ContentToStringStream(Status const & status);
  bool ok() const;
  Status status() const;
  ContentToStringStream value() const;
  StatusOr_ContentToStringStream(StatusOr_ContentToStringStream const & other);
  ~StatusOr_ContentToStringStream() {
    if (swig_owns_self_)
      inworld_StatusOr_ContentToStringStream_delete(swig_self_);
  }

  explicit StatusOr_ContentToStringStream(SwigObj_inworld_StatusOr_ContentToStringStream* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_ContentToStringStream& operator=(StatusOr_ContentToStringStream const&) = delete;
  StatusOr_ContentToStringStream(StatusOr_ContentToStringStream&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_ContentToStringStream& operator=(StatusOr_ContentToStringStream&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_ContentToStringStream_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_ContentToStringStream* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_ContentToStringStream* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_NERInterface {
public:
  StatusOr_NERInterface();
  StatusOr_NERInterface(NERInterface const& value);
  StatusOr_NERInterface(Status const & status);
  bool ok() const;
  Status status() const;
  NERInterface value() const;
  StatusOr_NERInterface(StatusOr_NERInterface const & other);
  ~StatusOr_NERInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_NERInterface_delete(swig_self_);
  }

  explicit StatusOr_NERInterface(SwigObj_inworld_StatusOr_NERInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_NERInterface& operator=(StatusOr_NERInterface const&) = delete;
  StatusOr_NERInterface(StatusOr_NERInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_NERInterface& operator=(StatusOr_NERInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_NERInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_NERInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_NERInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_CreationContext {
public:
  StatusOr_CreationContext();
  StatusOr_CreationContext(CreationContext const & value);
  StatusOr_CreationContext(Status const & status);
  bool ok() const;
  Status status() const;
  CreationContext value() const;
  StatusOr_CreationContext(StatusOr_CreationContext const & other);
  ~StatusOr_CreationContext() {
    if (swig_owns_self_)
      inworld_StatusOr_CreationContext_delete(swig_self_);
  }

  explicit StatusOr_CreationContext(SwigObj_inworld_StatusOr_CreationContext* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_CreationContext& operator=(StatusOr_CreationContext const&) = delete;
  StatusOr_CreationContext(StatusOr_CreationContext&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_CreationContext& operator=(StatusOr_CreationContext&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_CreationContext_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_CreationContext* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_CreationContext* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_MCPClientInterface {
public:
  StatusOr_MCPClientInterface();
  StatusOr_MCPClientInterface(MCPClientInterface const& value);
  StatusOr_MCPClientInterface(Status const & status);
  bool ok() const;
  Status status() const;
  MCPClientInterface value() const;
  StatusOr_MCPClientInterface(StatusOr_MCPClientInterface const & other);
  ~StatusOr_MCPClientInterface() {
    if (swig_owns_self_)
      inworld_StatusOr_MCPClientInterface_delete(swig_self_);
  }

  explicit StatusOr_MCPClientInterface(SwigObj_inworld_StatusOr_MCPClientInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_MCPClientInterface& operator=(StatusOr_MCPClientInterface const&) = delete;
  StatusOr_MCPClientInterface(StatusOr_MCPClientInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_MCPClientInterface& operator=(StatusOr_MCPClientInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_MCPClientInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_MCPClientInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_MCPClientInterface* swig_self_;
  bool swig_owns_self_;
};

class ComponentStore {
public:
  ComponentStore();
  ~ComponentStore() {
    if (swig_owns_self_)
      inworld_ComponentStore_delete(swig_self_);
  }
  void Clear();
  Status AddComponent_LLMInterface(std::string const& id, LLMInterface const& arg3);
  Status AddComponent_STTInterface(std::string const& id, STTInterface const& arg3);
  Status AddComponent_StreamingSTTInterface(std::string const& id, StreamingSTTInterface const& arg3);
  Status AddComponent_TTSInterface(std::string const& id, TTSInterface const& arg3);
  Status AddComponent_TextEmbedderInterface(std::string const& id, TextEmbedderInterface const& arg3);
  Status AddComponent_KnowledgeInterface(std::string const& id, KnowledgeInterface const& arg3);
  Status AddComponent_MCPClientInterface(std::string const& id, MCPClientInterface const& arg3);

  explicit ComponentStore(SwigObj_inworld_ComponentStore* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ComponentStore(ComponentStore const&) = delete;
  ComponentStore& operator=(ComponentStore const&) = delete;
  ComponentStore(ComponentStore&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ComponentStore& operator=(ComponentStore&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ComponentStore_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ComponentStore* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ComponentStore* swig_self_;
  bool swig_owns_self_;
};

class CreationContext {
public:
  CreationContext(ComponentStore * component_store);
  StatusOr_LLMInterface GetComponent_LLMInterface(std::string const& id);
  StatusOr_STTInterface GetComponent_STTInterface(std::string const& id);
  StatusOr_StreamingSTTInterface GetComponent_StreamingSTTInterface(std::string const& id);
  StatusOr_TTSInterface GetComponent_TTSInterface(std::string const& id);
  StatusOr_TextEmbedderInterface GetComponent_TextEmbedderInterface(std::string const& id);
  StatusOr_KnowledgeInterface GetComponent_KnowledgeInterface(std::string const& id);
  StatusOr_MCPClientInterface GetComponent_MCPClientInterface(std::string const& id);
  CreationContext(CreationContext const & other);
  ~CreationContext() {
    if (swig_owns_self_)
      inworld_CreationContext_delete(swig_self_);
  }

  explicit CreationContext(SwigObj_inworld_CreationContext* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CreationContext& operator=(CreationContext const&) = delete;
  CreationContext(CreationContext&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CreationContext& operator=(CreationContext&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CreationContext_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CreationContext* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CreationContext* swig_self_;
  bool swig_owns_self_;
};

class ComponentRegistry {
public:
  static ComponentRegistry GetInstance();
  bool IsComponentRegistered(std::string const& type);
  Status UnregisterComponent(std::string const& type);
  void Clear();
  StatusOr_LLMInterface CreateComponent_LLMInterface(std::string const& id, CreationContext const & arg3, LocalLLMConfig const & arg4);
  StatusOr_LLMInterface CreateComponent_LLMInterface(std::string const& id, CreationContext const & arg3, RemoteLLMConfig const & arg4);
  StatusOr_LLMInterface CreateComponent_LLMRouting(std::string const& id, CreationContext const & arg3, LLMRoutingCreationConfig const & arg4);
  StatusOr_STTInterface CreateComponent_STTInterface(std::string const& id, CreationContext const & arg3, LocalSTTConfig const & arg4);
  StatusOr_STTInterface CreateComponent_STTInterface(std::string const& id, CreationContext const & arg3, RemoteSTTConfig const & arg4);
  StatusOr_StreamingSTTInterface CreateComponent_StreamingSTTInterface(std::string const& id, CreationContext const & arg3, LocalStreamingSTTConfig const & arg4);
  StatusOr_StreamingSTTInterface CreateComponent_StreamingSTTInterface(std::string const& id, CreationContext const & arg3, RemoteStreamingSTTConfig const & arg4);
  StatusOr_TTSInterface CreateComponent_TTSInterface(std::string const& id, CreationContext const & arg3, RemoteTTSConfig const & arg4);
  StatusOr_TextEmbedderInterface CreateComponent_TextEmbedderInterface(std::string const& id, CreationContext const & arg3, LocalTextEmbedderConfig const & arg4);
  StatusOr_TextEmbedderInterface CreateComponent_TextEmbedderInterface(std::string const& id, CreationContext const & arg3, RemoteTextEmbedderConfig const & arg4);
  StatusOr_KnowledgeInterface CreateComponent_KnowledgeInterface(std::string const& id, CreationContext const & arg3, LocalKnowledgeConfig const & arg4);
  StatusOr_KnowledgeInterface CreateComponent_KnowledgeInterface(std::string const& id, CreationContext const & arg3, RemoteKnowledgeConfig const & arg4);
  StatusOr_MCPClientInterface CreateComponent_MCPClientInterface(std::string const& id, CreationContext const & arg3, MCPClientCreationConfig const & arg4);
  Status RegisterCustomEdgeCondition(std::string const& name, EdgeConditionExecutor const & arg3);
  Status RegisterCustomEdgeCondition(std::string const& name, EdgeConditionThreadedExecutor const & arg3);
  Status RegisterCustomNode(std::string const& type, CustomNodeThreadedCreateExecutor const & arg3);

  explicit ComponentRegistry(SwigObj_inworld_ComponentRegistry* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ComponentRegistry(ComponentRegistry const&) = delete;
  ComponentRegistry& operator=(ComponentRegistry const&) = delete;
  ComponentRegistry(ComponentRegistry&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ComponentRegistry& operator=(ComponentRegistry&& obj) noexcept {
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ComponentRegistry* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ComponentRegistry* swig_self_;
  bool swig_owns_self_;
};

class vector_StatusCode {
public:
  vector_StatusCode();
  vector_StatusCode(vector_StatusCode const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(StatusCode & x);
  StatusCode get(int i);
  void set(int i, StatusCode & arg3);
  ~vector_StatusCode() {
    if (swig_owns_self_)
      inworld_vector_StatusCode_delete(swig_self_);
  }

  explicit vector_StatusCode(SwigObj_inworld_vector_StatusCode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_StatusCode& operator=(vector_StatusCode const&) = delete;
  vector_StatusCode(vector_StatusCode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_StatusCode& operator=(vector_StatusCode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_StatusCode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_StatusCode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_StatusCode* swig_self_;
  bool swig_owns_self_;
};

class NodeExecutionConfig {
public:
  static NodeExecutionConfig null() { return NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void report_to_client(bool report_to_client);
  bool report_to_client() const;
  void properties(map_string_string * properties);
  map_string_string * properties() const;
  virtual ~NodeExecutionConfig() {
    if (swig_owns_self_)
      inworld_NodeExecutionConfig_delete(swig_self_);
  }
  bool is_valid() const;
  StatusOr_string toJsonString() const;
  static NodeExecutionConfig inworld_inworld_graphs_NodeExecutionConfig_CreateWithReportFlag__SWIG(bool report_to_client);
  static NodeExecutionConfig inworld_inworld_graphs_NodeExecutionConfig_CreateWithProperties__SWIG(bool report_to_client, map_string_string const & arg2);

  explicit NodeExecutionConfig(SwigObj_inworld_NodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  NodeExecutionConfig(NodeExecutionConfig const&) = delete;
  NodeExecutionConfig& operator=(NodeExecutionConfig const&) = delete;
  NodeExecutionConfig(NodeExecutionConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  NodeExecutionConfig& operator=(NodeExecutionConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_NodeExecutionConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_NodeExecutionConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_NodeExecutionConfig* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_CustomConfigWrapper {
public:
  StatusOr_CustomConfigWrapper();
  StatusOr_CustomConfigWrapper(CustomConfigWrapper const& value);
  StatusOr_CustomConfigWrapper(Status const & status);
  bool ok() const;
  Status status() const;
  CustomConfigWrapper value() const;
  StatusOr_CustomConfigWrapper(StatusOr_CustomConfigWrapper const & other);
  ~StatusOr_CustomConfigWrapper() {
    if (swig_owns_self_)
      inworld_StatusOr_CustomConfigWrapper_delete(swig_self_);
  }

  explicit StatusOr_CustomConfigWrapper(SwigObj_inworld_StatusOr_CustomConfigWrapper* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_CustomConfigWrapper& operator=(StatusOr_CustomConfigWrapper const&) = delete;
  StatusOr_CustomConfigWrapper(StatusOr_CustomConfigWrapper&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_CustomConfigWrapper& operator=(StatusOr_CustomConfigWrapper&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_CustomConfigWrapper_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_CustomConfigWrapper* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_CustomConfigWrapper* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_CustomExecutionConfigWrapper {
public:
  StatusOr_CustomExecutionConfigWrapper();
  StatusOr_CustomExecutionConfigWrapper(CustomExecutionConfigWrapper const& value);
  StatusOr_CustomExecutionConfigWrapper(Status const & status);
  bool ok() const;
  Status status() const;
  CustomExecutionConfigWrapper value() const;
  StatusOr_CustomExecutionConfigWrapper(StatusOr_CustomExecutionConfigWrapper const & other);
  ~StatusOr_CustomExecutionConfigWrapper() {
    if (swig_owns_self_)
      inworld_StatusOr_CustomExecutionConfigWrapper_delete(swig_self_);
  }

  explicit StatusOr_CustomExecutionConfigWrapper(SwigObj_inworld_StatusOr_CustomExecutionConfigWrapper* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_CustomExecutionConfigWrapper& operator=(StatusOr_CustomExecutionConfigWrapper const&) = delete;
  StatusOr_CustomExecutionConfigWrapper(StatusOr_CustomExecutionConfigWrapper&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_CustomExecutionConfigWrapper& operator=(StatusOr_CustomExecutionConfigWrapper&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_CustomExecutionConfigWrapper_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_CustomExecutionConfigWrapper* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_CustomExecutionConfigWrapper* swig_self_;
  bool swig_owns_self_;
};

class vector_CustomConfigWrapper {
public:
  vector_CustomConfigWrapper();
  vector_CustomConfigWrapper(vector_CustomConfigWrapper const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(CustomConfigWrapper const& x);
  CustomConfigWrapper get(int i);
  void set(int i, CustomConfigWrapper const& arg3);
  CustomConfigWrapper safe_get(size_t index) const;
  ~vector_CustomConfigWrapper() {
    if (swig_owns_self_)
      inworld_vector_CustomConfigWrapper_delete(swig_self_);
  }

  explicit vector_CustomConfigWrapper(SwigObj_inworld_vector_CustomConfigWrapper* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_CustomConfigWrapper& operator=(vector_CustomConfigWrapper const&) = delete;
  vector_CustomConfigWrapper(vector_CustomConfigWrapper&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_CustomConfigWrapper& operator=(vector_CustomConfigWrapper&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_CustomConfigWrapper_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_CustomConfigWrapper* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_CustomConfigWrapper* swig_self_;
  bool swig_owns_self_;
};

class vector_CustomExecutionConfigWrapper {
public:
  vector_CustomExecutionConfigWrapper();
  vector_CustomExecutionConfigWrapper(vector_CustomExecutionConfigWrapper const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(CustomExecutionConfigWrapper const& x);
  CustomExecutionConfigWrapper get(int i);
  void set(int i, CustomExecutionConfigWrapper const& arg3);
  CustomExecutionConfigWrapper safe_get(size_t index) const;
  ~vector_CustomExecutionConfigWrapper() {
    if (swig_owns_self_)
      inworld_vector_CustomExecutionConfigWrapper_delete(swig_self_);
  }

  explicit vector_CustomExecutionConfigWrapper(SwigObj_inworld_vector_CustomExecutionConfigWrapper* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_CustomExecutionConfigWrapper& operator=(vector_CustomExecutionConfigWrapper const&) = delete;
  vector_CustomExecutionConfigWrapper(vector_CustomExecutionConfigWrapper&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_CustomExecutionConfigWrapper& operator=(vector_CustomExecutionConfigWrapper&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_CustomExecutionConfigWrapper_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_CustomExecutionConfigWrapper* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_CustomExecutionConfigWrapper* swig_self_;
  bool swig_owns_self_;
};

class SerializerRegistry {
public:
  static SerializerRegistry GetInstance();
  void Clear();
  Status RegisterCustomConfig(const char * type, CustomConfigThreadedDeserializeExecutor const & arg3, CustomConfigThreadedSerializeExecutor const & arg4);
  Status RegisterCustomExecutionConfig(const char * type, CustomExecutionConfigThreadedDeserializeExecutor const & arg3, CustomExecutionConfigThreadedSerializeExecutor const & arg4);
  StatusOr_CustomConfigWrapper DeserializeCustomConfig(const char * type, const char * arg3);
  StatusOr_string SerializeCustomConfig(const char * type, CustomConfigWrapper const& arg3);
  StatusOr_CustomExecutionConfigWrapper DeserializeCustomExecutionConfig(const char * type, const char * arg3);
  StatusOr_string SerializeCustomExecutionConfig(const char * type, CustomExecutionConfigWrapper const& arg3);

  explicit SerializerRegistry(SwigObj_inworld_SerializerRegistry* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SerializerRegistry(SerializerRegistry const&) = delete;
  SerializerRegistry& operator=(SerializerRegistry const&) = delete;
  SerializerRegistry(SerializerRegistry&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SerializerRegistry& operator=(SerializerRegistry&& obj) noexcept {
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SerializerRegistry* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SerializerRegistry* swig_self_;
  bool swig_owns_self_;
};

class ConfigWrapperDestructor {
public:
  ConfigWrapperDestructor(void * context, void * arg2);
  ~ConfigWrapperDestructor() {
    if (swig_owns_self_)
      inworld_ConfigWrapperDestructor_delete(swig_self_);
  }
  ConfigWrapperDestructor(ConfigWrapperDestructor const & other);

  explicit ConfigWrapperDestructor(SwigObj_inworld_ConfigWrapperDestructor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ConfigWrapperDestructor& operator=(ConfigWrapperDestructor const&) = delete;
  ConfigWrapperDestructor(ConfigWrapperDestructor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ConfigWrapperDestructor& operator=(ConfigWrapperDestructor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ConfigWrapperDestructor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ConfigWrapperDestructor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ConfigWrapperDestructor* swig_self_;
  bool swig_owns_self_;
};

class CustomConfigWrapper {
public:
  static CustomConfigWrapper null() { return CustomConfigWrapper{(SwigObj_inworld_CustomConfigWrapper*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  CustomConfigWrapper(const char * type_id, void * arg2, ConfigWrapperDestructor const & arg3);
  ~CustomConfigWrapper() {
    if (swig_owns_self_)
      inworld_CustomConfigWrapper_delete(swig_self_);
  }
  const char * type_id() const;
  void * value() const;

  explicit CustomConfigWrapper(SwigObj_inworld_CustomConfigWrapper* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomConfigWrapper(CustomConfigWrapper const&) = delete;
  CustomConfigWrapper& operator=(CustomConfigWrapper const&) = delete;
  CustomConfigWrapper(CustomConfigWrapper&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomConfigWrapper& operator=(CustomConfigWrapper&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomConfigWrapper_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomConfigWrapper* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomConfigWrapper* swig_self_;
  bool swig_owns_self_;
};

class CustomExecutionConfigWrapper : public NodeExecutionConfig {
public:
  static CustomExecutionConfigWrapper null() { return CustomExecutionConfigWrapper{(SwigObj_inworld_CustomExecutionConfigWrapper*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  CustomExecutionConfigWrapper(const char * type_id, void * arg2, bool arg3, ConfigWrapperDestructor const & arg4);
  ~CustomExecutionConfigWrapper() {
    if (swig_owns_self_) {
      inworld_CustomExecutionConfigWrapper_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  const char * type_id() const;
  void * value() const;

  explicit CustomExecutionConfigWrapper(SwigObj_inworld_CustomExecutionConfigWrapper* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  CustomExecutionConfigWrapper(CustomExecutionConfigWrapper const&) = delete;
  CustomExecutionConfigWrapper& operator=(CustomExecutionConfigWrapper const&) = delete;
  CustomExecutionConfigWrapper(CustomExecutionConfigWrapper&& obj) = default;
  CustomExecutionConfigWrapper& operator=(CustomExecutionConfigWrapper&& obj) = default;
  SwigObj_inworld_CustomExecutionConfigWrapper* swig_self() const noexcept { return (SwigObj_inworld_CustomExecutionConfigWrapper*)NodeExecutionConfig::swig_self(); }
};

class CustomConfigThreadedSerializeExecutor {
public:
  CustomConfigThreadedSerializeExecutor(void * context, void * arg2);
  ~CustomConfigThreadedSerializeExecutor() {
    if (swig_owns_self_)
      inworld_CustomConfigThreadedSerializeExecutor_delete(swig_self_);
  }
  static CustomConfigWrapper GetInput(int execution_id);
  static void SetOutput(int execution_id, const char * arg2);
  CustomConfigThreadedSerializeExecutor(CustomConfigThreadedSerializeExecutor const & other);

  explicit CustomConfigThreadedSerializeExecutor(SwigObj_inworld_CustomConfigThreadedSerializeExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomConfigThreadedSerializeExecutor& operator=(CustomConfigThreadedSerializeExecutor const&) = delete;
  CustomConfigThreadedSerializeExecutor(CustomConfigThreadedSerializeExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomConfigThreadedSerializeExecutor& operator=(CustomConfigThreadedSerializeExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomConfigThreadedSerializeExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomConfigThreadedSerializeExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomConfigThreadedSerializeExecutor* swig_self_;
  bool swig_owns_self_;
};

class CustomConfigThreadedDeserializeExecutor {
public:
  CustomConfigThreadedDeserializeExecutor(void * context, void * arg2);
  ~CustomConfigThreadedDeserializeExecutor() {
    if (swig_owns_self_)
      inworld_CustomConfigThreadedDeserializeExecutor_delete(swig_self_);
  }
  static std::string GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_CustomConfigWrapper const & arg2);
  CustomConfigThreadedDeserializeExecutor(CustomConfigThreadedDeserializeExecutor const & other);

  explicit CustomConfigThreadedDeserializeExecutor(SwigObj_inworld_CustomConfigThreadedDeserializeExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomConfigThreadedDeserializeExecutor& operator=(CustomConfigThreadedDeserializeExecutor const&) = delete;
  CustomConfigThreadedDeserializeExecutor(CustomConfigThreadedDeserializeExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomConfigThreadedDeserializeExecutor& operator=(CustomConfigThreadedDeserializeExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomConfigThreadedDeserializeExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomConfigThreadedDeserializeExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomConfigThreadedDeserializeExecutor* swig_self_;
  bool swig_owns_self_;
};

class CustomExecutionConfigThreadedSerializeExecutor {
public:
  CustomExecutionConfigThreadedSerializeExecutor(void * context, void * arg2);
  ~CustomExecutionConfigThreadedSerializeExecutor() {
    if (swig_owns_self_)
      inworld_CustomExecutionConfigThreadedSerializeExecutor_delete(swig_self_);
  }
  static CustomExecutionConfigWrapper GetInput(int execution_id);
  static void SetOutput(int execution_id, const char * arg2);
  CustomExecutionConfigThreadedSerializeExecutor(CustomExecutionConfigThreadedSerializeExecutor const & other);

  explicit CustomExecutionConfigThreadedSerializeExecutor(SwigObj_inworld_CustomExecutionConfigThreadedSerializeExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomExecutionConfigThreadedSerializeExecutor& operator=(CustomExecutionConfigThreadedSerializeExecutor const&) = delete;
  CustomExecutionConfigThreadedSerializeExecutor(CustomExecutionConfigThreadedSerializeExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomExecutionConfigThreadedSerializeExecutor& operator=(CustomExecutionConfigThreadedSerializeExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomExecutionConfigThreadedSerializeExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomExecutionConfigThreadedSerializeExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomExecutionConfigThreadedSerializeExecutor* swig_self_;
  bool swig_owns_self_;
};

class CustomExecutionConfigThreadedDeserializeExecutor {
public:
  CustomExecutionConfigThreadedDeserializeExecutor(void * context, void * arg2);
  ~CustomExecutionConfigThreadedDeserializeExecutor() {
    if (swig_owns_self_)
      inworld_CustomExecutionConfigThreadedDeserializeExecutor_delete(swig_self_);
  }
  static std::string GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_CustomExecutionConfigWrapper const & arg2);
  CustomExecutionConfigThreadedDeserializeExecutor(CustomExecutionConfigThreadedDeserializeExecutor const & other);

  explicit CustomExecutionConfigThreadedDeserializeExecutor(SwigObj_inworld_CustomExecutionConfigThreadedDeserializeExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomExecutionConfigThreadedDeserializeExecutor& operator=(CustomExecutionConfigThreadedDeserializeExecutor const&) = delete;
  CustomExecutionConfigThreadedDeserializeExecutor(CustomExecutionConfigThreadedDeserializeExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomExecutionConfigThreadedDeserializeExecutor& operator=(CustomExecutionConfigThreadedDeserializeExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomExecutionConfigThreadedDeserializeExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomExecutionConfigThreadedDeserializeExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomExecutionConfigThreadedDeserializeExecutor* swig_self_;
  bool swig_owns_self_;
};

class InputStream_TTSOutput {
public:
  static InputStream_TTSOutput null() { return InputStream_TTSOutput{(SwigObj_inworld_InputStream_TTSOutput*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~InputStream_TTSOutput() {
    if (swig_owns_self_)
      inworld_InputStream_TTSOutput_delete(swig_self_);
  }
  virtual bool HasNext();
  virtual StatusOr_TTSOutput Read();
  virtual void Cancel();
  bool is_valid() const;

  explicit InputStream_TTSOutput(SwigObj_inworld_InputStream_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  InputStream_TTSOutput(InputStream_TTSOutput const&) = delete;
  InputStream_TTSOutput& operator=(InputStream_TTSOutput const&) = delete;
  InputStream_TTSOutput(InputStream_TTSOutput&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  InputStream_TTSOutput& operator=(InputStream_TTSOutput&& obj) noexcept {
    if (swig_owns_self_)
      inworld_InputStream_TTSOutput_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_InputStream_TTSOutput* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_InputStream_TTSOutput* swig_self_;
  bool swig_owns_self_;
};

class InputStream_Content {
public:
  static InputStream_Content null() { return InputStream_Content{(SwigObj_inworld_InputStream_Content*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~InputStream_Content() {
    if (swig_owns_self_)
      inworld_InputStream_Content_delete(swig_self_);
  }
  virtual bool HasNext();
  virtual StatusOr_Content Read();
  virtual void Cancel();
  bool is_valid() const;

  explicit InputStream_Content(SwigObj_inworld_InputStream_Content* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  InputStream_Content(InputStream_Content const&) = delete;
  InputStream_Content& operator=(InputStream_Content const&) = delete;
  InputStream_Content(InputStream_Content&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  InputStream_Content& operator=(InputStream_Content&& obj) noexcept {
    if (swig_owns_self_)
      inworld_InputStream_Content_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_InputStream_Content* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_InputStream_Content* swig_self_;
  bool swig_owns_self_;
};

class InputStream_string {
public:
  static InputStream_string null() { return InputStream_string{(SwigObj_inworld_InputStream_string*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~InputStream_string() {
    if (swig_owns_self_)
      inworld_InputStream_string_delete(swig_self_);
  }
  virtual bool HasNext();
  virtual StatusOr_string Read();
  virtual void Cancel();
  bool is_valid() const;

  explicit InputStream_string(SwigObj_inworld_InputStream_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  InputStream_string(InputStream_string const&) = delete;
  InputStream_string& operator=(InputStream_string const&) = delete;
  InputStream_string(InputStream_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  InputStream_string& operator=(InputStream_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_InputStream_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_InputStream_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_InputStream_string* swig_self_;
  bool swig_owns_self_;
};

class InputStream_AudioChunk {
public:
  static InputStream_AudioChunk null() { return InputStream_AudioChunk{(SwigObj_inworld_InputStream_AudioChunk*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~InputStream_AudioChunk() {
    if (swig_owns_self_)
      inworld_InputStream_AudioChunk_delete(swig_self_);
  }
  virtual bool HasNext();
  virtual StatusOr_AudioChunk Read();
  virtual void Cancel();
  bool is_valid() const;

  explicit InputStream_AudioChunk(SwigObj_inworld_InputStream_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  InputStream_AudioChunk(InputStream_AudioChunk const&) = delete;
  InputStream_AudioChunk& operator=(InputStream_AudioChunk const&) = delete;
  InputStream_AudioChunk(InputStream_AudioChunk&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  InputStream_AudioChunk& operator=(InputStream_AudioChunk&& obj) noexcept {
    if (swig_owns_self_)
      inworld_InputStream_AudioChunk_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_InputStream_AudioChunk* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_InputStream_AudioChunk* swig_self_;
  bool swig_owns_self_;
};

class InputStream_BaseData {
public:
  static InputStream_BaseData null() { return InputStream_BaseData{(SwigObj_inworld_InputStream_BaseData*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~InputStream_BaseData() {
    if (swig_owns_self_)
      inworld_InputStream_BaseData_delete(swig_self_);
  }
  virtual bool HasNext();
  virtual StatusOr_BaseData Read();
  virtual void Cancel();
  bool is_valid() const;

  explicit InputStream_BaseData(SwigObj_inworld_InputStream_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  InputStream_BaseData(InputStream_BaseData const&) = delete;
  InputStream_BaseData& operator=(InputStream_BaseData const&) = delete;
  InputStream_BaseData(InputStream_BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  InputStream_BaseData& operator=(InputStream_BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_InputStream_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_InputStream_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_InputStream_BaseData* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_InputStream_string {
public:
  StatusOr_InputStream_string();
  StatusOr_InputStream_string(InputStream_string const& value);
  StatusOr_InputStream_string(Status const & status);
  bool ok() const;
  Status status() const;
  InputStream_string value() const;
  StatusOr_InputStream_string(StatusOr_InputStream_string const & other);
  ~StatusOr_InputStream_string() {
    if (swig_owns_self_)
      inworld_StatusOr_InputStream_string_delete(swig_self_);
  }

  explicit StatusOr_InputStream_string(SwigObj_inworld_StatusOr_InputStream_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_InputStream_string& operator=(StatusOr_InputStream_string const&) = delete;
  StatusOr_InputStream_string(StatusOr_InputStream_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_InputStream_string& operator=(StatusOr_InputStream_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_InputStream_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_InputStream_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_InputStream_string* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_InputStream_AudioChunk {
public:
  StatusOr_InputStream_AudioChunk();
  StatusOr_InputStream_AudioChunk(InputStream_AudioChunk const& value);
  StatusOr_InputStream_AudioChunk(Status const & status);
  bool ok() const;
  Status status() const;
  InputStream_AudioChunk value() const;
  StatusOr_InputStream_AudioChunk(StatusOr_InputStream_AudioChunk const & other);
  ~StatusOr_InputStream_AudioChunk() {
    if (swig_owns_self_)
      inworld_StatusOr_InputStream_AudioChunk_delete(swig_self_);
  }

  explicit StatusOr_InputStream_AudioChunk(SwigObj_inworld_StatusOr_InputStream_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_InputStream_AudioChunk& operator=(StatusOr_InputStream_AudioChunk const&) = delete;
  StatusOr_InputStream_AudioChunk(StatusOr_InputStream_AudioChunk&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_InputStream_AudioChunk& operator=(StatusOr_InputStream_AudioChunk&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_InputStream_AudioChunk_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_InputStream_AudioChunk* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_InputStream_AudioChunk* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_InputStream_Content {
public:
  StatusOr_InputStream_Content();
  StatusOr_InputStream_Content(InputStream_Content const& value);
  StatusOr_InputStream_Content(Status const & status);
  bool ok() const;
  Status status() const;
  InputStream_Content value() const;
  StatusOr_InputStream_Content(StatusOr_InputStream_Content const & other);
  ~StatusOr_InputStream_Content() {
    if (swig_owns_self_)
      inworld_StatusOr_InputStream_Content_delete(swig_self_);
  }

  explicit StatusOr_InputStream_Content(SwigObj_inworld_StatusOr_InputStream_Content* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_InputStream_Content& operator=(StatusOr_InputStream_Content const&) = delete;
  StatusOr_InputStream_Content(StatusOr_InputStream_Content&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_InputStream_Content& operator=(StatusOr_InputStream_Content&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_InputStream_Content_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_InputStream_Content* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_InputStream_Content* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_InputStream_BaseData {
public:
  StatusOr_InputStream_BaseData();
  StatusOr_InputStream_BaseData(InputStream_BaseData const& value);
  StatusOr_InputStream_BaseData(Status const & status);
  bool ok() const;
  Status status() const;
  InputStream_BaseData value() const;
  StatusOr_InputStream_BaseData(StatusOr_InputStream_BaseData const & other);
  ~StatusOr_InputStream_BaseData() {
    if (swig_owns_self_)
      inworld_StatusOr_InputStream_BaseData_delete(swig_self_);
  }

  explicit StatusOr_InputStream_BaseData(SwigObj_inworld_StatusOr_InputStream_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_InputStream_BaseData& operator=(StatusOr_InputStream_BaseData const&) = delete;
  StatusOr_InputStream_BaseData(StatusOr_InputStream_BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_InputStream_BaseData& operator=(StatusOr_InputStream_BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_InputStream_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_InputStream_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_InputStream_BaseData* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_InputStream_TTSOutput {
public:
  StatusOr_InputStream_TTSOutput();
  StatusOr_InputStream_TTSOutput(InputStream_TTSOutput const& value);
  StatusOr_InputStream_TTSOutput(Status const & status);
  bool ok() const;
  Status status() const;
  InputStream_TTSOutput value() const;
  StatusOr_InputStream_TTSOutput(StatusOr_InputStream_TTSOutput const & other);
  ~StatusOr_InputStream_TTSOutput() {
    if (swig_owns_self_)
      inworld_StatusOr_InputStream_TTSOutput_delete(swig_self_);
  }

  explicit StatusOr_InputStream_TTSOutput(SwigObj_inworld_StatusOr_InputStream_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_InputStream_TTSOutput& operator=(StatusOr_InputStream_TTSOutput const&) = delete;
  StatusOr_InputStream_TTSOutput(StatusOr_InputStream_TTSOutput&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_InputStream_TTSOutput& operator=(StatusOr_InputStream_TTSOutput&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_InputStream_TTSOutput_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_InputStream_TTSOutput* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_InputStream_TTSOutput* swig_self_;
  bool swig_owns_self_;
};

class BlockingStream_TTSOutput : public InputStream_TTSOutput {
public:
  static BlockingStream_TTSOutput null() { return BlockingStream_TTSOutput{(SwigObj_inworld_BlockingStream_TTSOutput*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static BlockingStream_TTSOutput Create();
  ~BlockingStream_TTSOutput() {
    if (swig_owns_self_) {
      inworld_BlockingStream_TTSOutput_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool Write(TTSOutput const& value);
  void Close();
  void Close(Status const & status);
  bool is_valid() const;

  explicit BlockingStream_TTSOutput(SwigObj_inworld_BlockingStream_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : InputStream_TTSOutput{(SwigObj_inworld_InputStream_TTSOutput*)swig_self, swig_owns_self} {}
  BlockingStream_TTSOutput(BlockingStream_TTSOutput const&) = delete;
  BlockingStream_TTSOutput& operator=(BlockingStream_TTSOutput const&) = delete;
  BlockingStream_TTSOutput(BlockingStream_TTSOutput&& obj) = default;
  BlockingStream_TTSOutput& operator=(BlockingStream_TTSOutput&& obj) = default;
  SwigObj_inworld_BlockingStream_TTSOutput* swig_self() const noexcept { return (SwigObj_inworld_BlockingStream_TTSOutput*)InputStream_TTSOutput::swig_self(); }
};

class BlockingStream_Content : public InputStream_Content {
public:
  static BlockingStream_Content null() { return BlockingStream_Content{(SwigObj_inworld_BlockingStream_Content*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static BlockingStream_Content Create();
  ~BlockingStream_Content() {
    if (swig_owns_self_) {
      inworld_BlockingStream_Content_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool Write(Content const& value);
  void Close();
  void Close(Status const & status);
  bool is_valid() const;

  explicit BlockingStream_Content(SwigObj_inworld_BlockingStream_Content* swig_self, bool swig_owns_self = true) noexcept : InputStream_Content{(SwigObj_inworld_InputStream_Content*)swig_self, swig_owns_self} {}
  BlockingStream_Content(BlockingStream_Content const&) = delete;
  BlockingStream_Content& operator=(BlockingStream_Content const&) = delete;
  BlockingStream_Content(BlockingStream_Content&& obj) = default;
  BlockingStream_Content& operator=(BlockingStream_Content&& obj) = default;
  SwigObj_inworld_BlockingStream_Content* swig_self() const noexcept { return (SwigObj_inworld_BlockingStream_Content*)InputStream_Content::swig_self(); }
};

class BlockingStream_AudioChunk : public InputStream_AudioChunk {
public:
  static BlockingStream_AudioChunk null() { return BlockingStream_AudioChunk{(SwigObj_inworld_BlockingStream_AudioChunk*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static BlockingStream_AudioChunk Create();
  ~BlockingStream_AudioChunk() {
    if (swig_owns_self_) {
      inworld_BlockingStream_AudioChunk_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool Write(AudioChunk const& value);
  void Close();
  void Close(Status const & status);
  bool is_valid() const;

  explicit BlockingStream_AudioChunk(SwigObj_inworld_BlockingStream_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : InputStream_AudioChunk{(SwigObj_inworld_InputStream_AudioChunk*)swig_self, swig_owns_self} {}
  BlockingStream_AudioChunk(BlockingStream_AudioChunk const&) = delete;
  BlockingStream_AudioChunk& operator=(BlockingStream_AudioChunk const&) = delete;
  BlockingStream_AudioChunk(BlockingStream_AudioChunk&& obj) = default;
  BlockingStream_AudioChunk& operator=(BlockingStream_AudioChunk&& obj) = default;
  SwigObj_inworld_BlockingStream_AudioChunk* swig_self() const noexcept { return (SwigObj_inworld_BlockingStream_AudioChunk*)InputStream_AudioChunk::swig_self(); }
};

class BlockingStream_string : public InputStream_string {
public:
  static BlockingStream_string null() { return BlockingStream_string{(SwigObj_inworld_BlockingStream_string*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static BlockingStream_string Create();
  ~BlockingStream_string() {
    if (swig_owns_self_) {
      inworld_BlockingStream_string_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool Write(std::string const& value);
  void Close();
  void Close(Status const & status);
  bool is_valid() const;

  explicit BlockingStream_string(SwigObj_inworld_BlockingStream_string* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  BlockingStream_string(BlockingStream_string const&) = delete;
  BlockingStream_string& operator=(BlockingStream_string const&) = delete;
  BlockingStream_string(BlockingStream_string&& obj) = default;
  BlockingStream_string& operator=(BlockingStream_string&& obj) = default;
  SwigObj_inworld_BlockingStream_string* swig_self() const noexcept { return (SwigObj_inworld_BlockingStream_string*)InputStream_string::swig_self(); }
};

class BlockingStream_BaseData : public InputStream_BaseData {
public:
  static BlockingStream_BaseData null() { return BlockingStream_BaseData{(SwigObj_inworld_BlockingStream_BaseData*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static BlockingStream_BaseData Create();
  ~BlockingStream_BaseData() {
    if (swig_owns_self_) {
      inworld_BlockingStream_BaseData_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool Write(BaseData const& value);
  void Close();
  void Close(Status const & status);
  bool is_valid() const;

  explicit BlockingStream_BaseData(SwigObj_inworld_BlockingStream_BaseData* swig_self, bool swig_owns_self = true) noexcept : InputStream_BaseData{(SwigObj_inworld_InputStream_BaseData*)swig_self, swig_owns_self} {}
  BlockingStream_BaseData(BlockingStream_BaseData const&) = delete;
  BlockingStream_BaseData& operator=(BlockingStream_BaseData const&) = delete;
  BlockingStream_BaseData(BlockingStream_BaseData&& obj) = default;
  BlockingStream_BaseData& operator=(BlockingStream_BaseData&& obj) = default;
  SwigObj_inworld_BlockingStream_BaseData* swig_self() const noexcept { return (SwigObj_inworld_BlockingStream_BaseData*)InputStream_BaseData::swig_self(); }
};

class StatusOr_CustomStringStreamReadThruWrapper {
public:
  StatusOr_CustomStringStreamReadThruWrapper();
  StatusOr_CustomStringStreamReadThruWrapper(CustomStringStreamReadThruWrapper const& value);
  StatusOr_CustomStringStreamReadThruWrapper(Status const & status);
  bool ok() const;
  Status status() const;
  CustomStringStreamReadThruWrapper value() const;
  StatusOr_CustomStringStreamReadThruWrapper(StatusOr_CustomStringStreamReadThruWrapper const & other);
  ~StatusOr_CustomStringStreamReadThruWrapper() {
    if (swig_owns_self_)
      inworld_StatusOr_CustomStringStreamReadThruWrapper_delete(swig_self_);
  }

  explicit StatusOr_CustomStringStreamReadThruWrapper(SwigObj_inworld_StatusOr_CustomStringStreamReadThruWrapper* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_CustomStringStreamReadThruWrapper& operator=(StatusOr_CustomStringStreamReadThruWrapper const&) = delete;
  StatusOr_CustomStringStreamReadThruWrapper(StatusOr_CustomStringStreamReadThruWrapper&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_CustomStringStreamReadThruWrapper& operator=(StatusOr_CustomStringStreamReadThruWrapper&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_CustomStringStreamReadThruWrapper_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_CustomStringStreamReadThruWrapper* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_CustomStringStreamReadThruWrapper* swig_self_;
  bool swig_owns_self_;
};

class CustomStringStreamReadThruExecutor {
public:
  CustomStringStreamReadThruExecutor(void * source_object, void * arg2);
  CustomStringStreamReadThruExecutor(CustomStringStreamReadThruExecutor const & other);
  ~CustomStringStreamReadThruExecutor() {
    if (swig_owns_self_)
      inworld_CustomStringStreamReadThruExecutor_delete(swig_self_);
  }

  explicit CustomStringStreamReadThruExecutor(SwigObj_inworld_CustomStringStreamReadThruExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomStringStreamReadThruExecutor& operator=(CustomStringStreamReadThruExecutor const&) = delete;
  CustomStringStreamReadThruExecutor(CustomStringStreamReadThruExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomStringStreamReadThruExecutor& operator=(CustomStringStreamReadThruExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomStringStreamReadThruExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomStringStreamReadThruExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomStringStreamReadThruExecutor* swig_self_;
  bool swig_owns_self_;
};

class CustomStringStreamReadThruWrapper : public InputStream_string {
public:
  static CustomStringStreamReadThruWrapper null() { return CustomStringStreamReadThruWrapper{(SwigObj_inworld_CustomStringStreamReadThruWrapper*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static StatusOr_CustomStringStreamReadThruWrapper Create(InputStream_string const& input_stream, CustomStringStreamReadThruExecutor const & arg2);
  ~CustomStringStreamReadThruWrapper() {
    if (swig_owns_self_) {
      inworld_CustomStringStreamReadThruWrapper_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;
  CustomStringStreamReadThruWrapper(CustomStringStreamReadThruWrapper const & other);

  explicit CustomStringStreamReadThruWrapper(SwigObj_inworld_CustomStringStreamReadThruWrapper* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  CustomStringStreamReadThruWrapper& operator=(CustomStringStreamReadThruWrapper const&) = delete;
  CustomStringStreamReadThruWrapper(CustomStringStreamReadThruWrapper&& obj) = default;
  CustomStringStreamReadThruWrapper& operator=(CustomStringStreamReadThruWrapper&& obj) = default;
  SwigObj_inworld_CustomStringStreamReadThruWrapper* swig_self() const noexcept { return (SwigObj_inworld_CustomStringStreamReadThruWrapper*)InputStream_string::swig_self(); }
};

class ContentToStringStream : public InputStream_string {
public:
  static ContentToStringStream null() { return ContentToStringStream{(SwigObj_inworld_ContentToStringStream*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static StatusOr_ContentToStringStream Create(InputStream_Content const& content_stream);
  ~ContentToStringStream() {
    if (swig_owns_self_) {
      inworld_ContentToStringStream_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;

  explicit ContentToStringStream(SwigObj_inworld_ContentToStringStream* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  ContentToStringStream(ContentToStringStream const&) = delete;
  ContentToStringStream& operator=(ContentToStringStream const&) = delete;
  ContentToStringStream(ContentToStringStream&& obj) = default;
  ContentToStringStream& operator=(ContentToStringStream&& obj) = default;
  SwigObj_inworld_ContentToStringStream* swig_self() const noexcept { return (SwigObj_inworld_ContentToStringStream*)InputStream_string::swig_self(); }
};

class vector_CompiledIntent {
public:
  vector_CompiledIntent();
  vector_CompiledIntent(vector_CompiledIntent const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(CompiledIntent const & x);
  CompiledIntent get(int i);
  void set(int i, CompiledIntent const & arg3);
  ~vector_CompiledIntent() {
    if (swig_owns_self_)
      inworld_vector_CompiledIntent_delete(swig_self_);
  }

  explicit vector_CompiledIntent(SwigObj_inworld_vector_CompiledIntent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_CompiledIntent& operator=(vector_CompiledIntent const&) = delete;
  vector_CompiledIntent(vector_CompiledIntent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_CompiledIntent& operator=(vector_CompiledIntent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_CompiledIntent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_CompiledIntent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_CompiledIntent* swig_self_;
  bool swig_owns_self_;
};

class vector_Device {
public:
  vector_Device();
  vector_Device(vector_Device const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Device const & x);
  Device get(int i);
  void set(int i, Device const & arg3);
  ~vector_Device() {
    if (swig_owns_self_)
      inworld_vector_Device_delete(swig_self_);
  }

  explicit vector_Device(SwigObj_inworld_vector_Device* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_Device& operator=(vector_Device const&) = delete;
  vector_Device(vector_Device&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_Device& operator=(vector_Device&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_Device_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_Device* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_Device* swig_self_;
  bool swig_owns_self_;
};

class vector_Event {
public:
  vector_Event();
  vector_Event(vector_Event const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Event const & x);
  Event get(int i);
  void set(int i, Event const & arg3);
  ~vector_Event() {
    if (swig_owns_self_)
      inworld_vector_Event_delete(swig_self_);
  }

  explicit vector_Event(SwigObj_inworld_vector_Event* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_Event& operator=(vector_Event const&) = delete;
  vector_Event(vector_Event&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_Event& operator=(vector_Event&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_Event_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_Event* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_Event* swig_self_;
  bool swig_owns_self_;
};

class vector_Intent {
public:
  vector_Intent();
  vector_Intent(vector_Intent const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Intent const & x);
  Intent get(int i);
  void set(int i, Intent const & arg3);
  ~vector_Intent() {
    if (swig_owns_self_)
      inworld_vector_Intent_delete(swig_self_);
  }

  explicit vector_Intent(SwigObj_inworld_vector_Intent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_Intent& operator=(vector_Intent const&) = delete;
  vector_Intent(vector_Intent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_Intent& operator=(vector_Intent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_Intent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_Intent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_Intent* swig_self_;
  bool swig_owns_self_;
};

class vector_IntentMatch {
public:
  vector_IntentMatch();
  vector_IntentMatch(vector_IntentMatch const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(IntentMatch const & x);
  IntentMatch get(int i);
  void set(int i, IntentMatch const & arg3);
  ~vector_IntentMatch() {
    if (swig_owns_self_)
      inworld_vector_IntentMatch_delete(swig_self_);
  }

  explicit vector_IntentMatch(SwigObj_inworld_vector_IntentMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_IntentMatch& operator=(vector_IntentMatch const&) = delete;
  vector_IntentMatch(vector_IntentMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_IntentMatch& operator=(vector_IntentMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_IntentMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_IntentMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_IntentMatch* swig_self_;
  bool swig_owns_self_;
};

class vector_KeywordMatch {
public:
  vector_KeywordMatch();
  vector_KeywordMatch(vector_KeywordMatch const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(KeywordMatch const & x);
  KeywordMatch get(int i);
  void set(int i, KeywordMatch const & arg3);
  ~vector_KeywordMatch() {
    if (swig_owns_self_)
      inworld_vector_KeywordMatch_delete(swig_self_);
  }

  explicit vector_KeywordMatch(SwigObj_inworld_vector_KeywordMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_KeywordMatch& operator=(vector_KeywordMatch const&) = delete;
  vector_KeywordMatch(vector_KeywordMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_KeywordMatch& operator=(vector_KeywordMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_KeywordMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_KeywordMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_KeywordMatch* swig_self_;
  bool swig_owns_self_;
};

class vector_KeywordGroup {
public:
  vector_KeywordGroup();
  vector_KeywordGroup(vector_KeywordGroup const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(KeywordGroup const & x);
  KeywordGroup get(int i);
  void set(int i, KeywordGroup const & arg3);
  ~vector_KeywordGroup() {
    if (swig_owns_self_)
      inworld_vector_KeywordGroup_delete(swig_self_);
  }

  explicit vector_KeywordGroup(SwigObj_inworld_vector_KeywordGroup* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_KeywordGroup& operator=(vector_KeywordGroup const&) = delete;
  vector_KeywordGroup(vector_KeywordGroup&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_KeywordGroup& operator=(vector_KeywordGroup&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_KeywordGroup_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_KeywordGroup* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_KeywordGroup* swig_self_;
  bool swig_owns_self_;
};

class vector_PhraseMatch {
public:
  vector_PhraseMatch();
  vector_PhraseMatch(vector_PhraseMatch const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(PhraseMatch const & x);
  PhraseMatch get(int i);
  void set(int i, PhraseMatch const & arg3);
  ~vector_PhraseMatch() {
    if (swig_owns_self_)
      inworld_vector_PhraseMatch_delete(swig_self_);
  }

  explicit vector_PhraseMatch(SwigObj_inworld_vector_PhraseMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_PhraseMatch& operator=(vector_PhraseMatch const&) = delete;
  vector_PhraseMatch(vector_PhraseMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_PhraseMatch& operator=(vector_PhraseMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_PhraseMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_PhraseMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_PhraseMatch* swig_self_;
  bool swig_owns_self_;
};

class vector_KnowledgeRecord {
public:
  vector_KnowledgeRecord();
  vector_KnowledgeRecord(vector_KnowledgeRecord const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(KnowledgeRecord const & x);
  KnowledgeRecord get(int i);
  void set(int i, KnowledgeRecord const & arg3);
  ~vector_KnowledgeRecord() {
    if (swig_owns_self_)
      inworld_vector_KnowledgeRecord_delete(swig_self_);
  }

  explicit vector_KnowledgeRecord(SwigObj_inworld_vector_KnowledgeRecord* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_KnowledgeRecord& operator=(vector_KnowledgeRecord const&) = delete;
  vector_KnowledgeRecord(vector_KnowledgeRecord&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_KnowledgeRecord& operator=(vector_KnowledgeRecord&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_KnowledgeRecord_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_KnowledgeRecord* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_KnowledgeRecord* swig_self_;
  bool swig_owns_self_;
};

class vector_KnowledgeCollection {
public:
  vector_KnowledgeCollection();
  vector_KnowledgeCollection(vector_KnowledgeCollection const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(KnowledgeCollection const & x);
  KnowledgeCollection get(int i);
  void set(int i, KnowledgeCollection const & arg3);
  ~vector_KnowledgeCollection() {
    if (swig_owns_self_)
      inworld_vector_KnowledgeCollection_delete(swig_self_);
  }

  explicit vector_KnowledgeCollection(SwigObj_inworld_vector_KnowledgeCollection* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_KnowledgeCollection& operator=(vector_KnowledgeCollection const&) = delete;
  vector_KnowledgeCollection(vector_KnowledgeCollection&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_KnowledgeCollection& operator=(vector_KnowledgeCollection&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_KnowledgeCollection_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_KnowledgeCollection* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_KnowledgeCollection* swig_self_;
  bool swig_owns_self_;
};

class vector_LLMRoutingConfig {
public:
  vector_LLMRoutingConfig();
  vector_LLMRoutingConfig(vector_LLMRoutingConfig const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(LLMRoutingConfig const & x);
  LLMRoutingConfig get(int i);
  void set(int i, LLMRoutingConfig const & arg3);
  ~vector_LLMRoutingConfig() {
    if (swig_owns_self_)
      inworld_vector_LLMRoutingConfig_delete(swig_self_);
  }

  explicit vector_LLMRoutingConfig(SwigObj_inworld_vector_LLMRoutingConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_LLMRoutingConfig& operator=(vector_LLMRoutingConfig const&) = delete;
  vector_LLMRoutingConfig(vector_LLMRoutingConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_LLMRoutingConfig& operator=(vector_LLMRoutingConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_LLMRoutingConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_LLMRoutingConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_LLMRoutingConfig* swig_self_;
  bool swig_owns_self_;
};

class vector_TopicThreshold {
public:
  vector_TopicThreshold();
  vector_TopicThreshold(vector_TopicThreshold const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(TopicThreshold const & x);
  TopicThreshold get(int i);
  void set(int i, TopicThreshold const & arg3);
  ~vector_TopicThreshold() {
    if (swig_owns_self_)
      inworld_vector_TopicThreshold_delete(swig_self_);
  }

  explicit vector_TopicThreshold(SwigObj_inworld_vector_TopicThreshold* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_TopicThreshold& operator=(vector_TopicThreshold const&) = delete;
  vector_TopicThreshold(vector_TopicThreshold&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_TopicThreshold& operator=(vector_TopicThreshold&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_TopicThreshold_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_TopicThreshold* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_TopicThreshold* swig_self_;
  bool swig_owns_self_;
};

class vector_DetectedTopic {
public:
  vector_DetectedTopic();
  vector_DetectedTopic(vector_DetectedTopic const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(DetectedTopic const & x);
  DetectedTopic get(int i);
  void set(int i, DetectedTopic const & arg3);
  ~vector_DetectedTopic() {
    if (swig_owns_self_)
      inworld_vector_DetectedTopic_delete(swig_self_);
  }

  explicit vector_DetectedTopic(SwigObj_inworld_vector_DetectedTopic* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_DetectedTopic& operator=(vector_DetectedTopic const&) = delete;
  vector_DetectedTopic(vector_DetectedTopic&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_DetectedTopic& operator=(vector_DetectedTopic&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_DetectedTopic_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_DetectedTopic* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_DetectedTopic* swig_self_;
  bool swig_owns_self_;
};

class vector_DictionaryRule {
public:
  vector_DictionaryRule();
  vector_DictionaryRule(vector_DictionaryRule const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(DictionaryRule const & x);
  DictionaryRule get(int i);
  void set(int i, DictionaryRule const & arg3);
  ~vector_DictionaryRule() {
    if (swig_owns_self_)
      inworld_vector_DictionaryRule_delete(swig_self_);
  }

  explicit vector_DictionaryRule(SwigObj_inworld_vector_DictionaryRule* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_DictionaryRule& operator=(vector_DictionaryRule const&) = delete;
  vector_DictionaryRule(vector_DictionaryRule&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_DictionaryRule& operator=(vector_DictionaryRule&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_DictionaryRule_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_DictionaryRule* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_DictionaryRule* swig_self_;
  bool swig_owns_self_;
};

class vector_Entity {
public:
  vector_Entity();
  vector_Entity(vector_Entity const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Entity const & x);
  Entity get(int i);
  void set(int i, Entity const & arg3);
  ~vector_Entity() {
    if (swig_owns_self_)
      inworld_vector_Entity_delete(swig_self_);
  }

  explicit vector_Entity(SwigObj_inworld_vector_Entity* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_Entity& operator=(vector_Entity const&) = delete;
  vector_Entity(vector_Entity&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_Entity& operator=(vector_Entity&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_Entity_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_Entity* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_Entity* swig_self_;
  bool swig_owns_self_;
};

class vector_EntityMatch {
public:
  vector_EntityMatch();
  vector_EntityMatch(vector_EntityMatch const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(EntityMatch const & x);
  EntityMatch get(int i);
  void set(int i, EntityMatch const & arg3);
  ~vector_EntityMatch() {
    if (swig_owns_self_)
      inworld_vector_EntityMatch_delete(swig_self_);
  }

  explicit vector_EntityMatch(SwigObj_inworld_vector_EntityMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_EntityMatch& operator=(vector_EntityMatch const&) = delete;
  vector_EntityMatch(vector_EntityMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_EntityMatch& operator=(vector_EntityMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_EntityMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_EntityMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_EntityMatch* swig_self_;
  bool swig_owns_self_;
};

class vector_vector_float {
public:
  vector_vector_float();
  vector_vector_float(vector_vector_float const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(vector_float const & x);
  vector_float get(int i);
  void set(int i, vector_float const & arg3);
  ~vector_vector_float() {
    if (swig_owns_self_)
      inworld_vector_vector_float_delete(swig_self_);
  }

  explicit vector_vector_float(SwigObj_inworld_vector_vector_float* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_vector_float& operator=(vector_vector_float const&) = delete;
  vector_vector_float(vector_vector_float&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_vector_float& operator=(vector_vector_float&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_vector_float_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_vector_float* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_vector_float* swig_self_;
  bool swig_owns_self_;
};

class vector_string {
public:
  vector_string();
  vector_string(vector_string const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(std::string const& x);
  std::string get(int i);
  void set(int i, std::string const& arg3);
  ~vector_string() {
    if (swig_owns_self_)
      inworld_vector_string_delete(swig_self_);
  }

  explicit vector_string(SwigObj_inworld_vector_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_string& operator=(vector_string const&) = delete;
  vector_string(vector_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_string& operator=(vector_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_string* swig_self_;
  bool swig_owns_self_;
};

class vector_map_string_string {
public:
  vector_map_string_string();
  vector_map_string_string(vector_map_string_string const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(map_string_string const & x);
  map_string_string get(int i);
  void set(int i, map_string_string const & arg3);
  ~vector_map_string_string() {
    if (swig_owns_self_)
      inworld_vector_map_string_string_delete(swig_self_);
  }

  explicit vector_map_string_string(SwigObj_inworld_vector_map_string_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_map_string_string& operator=(vector_map_string_string const&) = delete;
  vector_map_string_string(vector_map_string_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_map_string_string& operator=(vector_map_string_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_map_string_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_map_string_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_map_string_string* swig_self_;
  bool swig_owns_self_;
};

class map_string_string {
public:
  map_string_string();
  map_string_string(map_string_string const & other);
  size_t size() const;
  bool empty() const;
  void clear();
  std::string get(std::string const& key);
  void set(std::string const& key, std::string const& arg3);
  void del(std::string const& key);
  bool has_key(std::string const& key) const;
  ~map_string_string() {
    if (swig_owns_self_)
      inworld_map_string_string_delete(swig_self_);
  }

  explicit map_string_string(SwigObj_inworld_map_string_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  map_string_string& operator=(map_string_string const&) = delete;
  map_string_string(map_string_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  map_string_string& operator=(map_string_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_map_string_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_map_string_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_map_string_string* swig_self_;
  bool swig_owns_self_;
};

class optional_BatchProcessingOptions {
public:
  optional_BatchProcessingOptions();
  optional_BatchProcessingOptions(BatchProcessingOptions const & value);
  optional_BatchProcessingOptions(optional_BatchProcessingOptions const & other);
  ~optional_BatchProcessingOptions() {
    if (swig_owns_self_)
      inworld_optional_BatchProcessingOptions_delete(swig_self_);
  }
  bool has_value() const;
  BatchProcessingOptions value();
  BatchProcessingOptions value() const;
  BatchProcessingOptions value_or(BatchProcessingOptions const & default_value) const;
  void reset();
  BatchProcessingOptions operator *();
  BatchProcessingOptions operator *() const;
  BatchProcessingOptions get_value();
  void set_value(BatchProcessingOptions & t);

  explicit optional_BatchProcessingOptions(SwigObj_inworld_optional_BatchProcessingOptions* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_BatchProcessingOptions& operator=(optional_BatchProcessingOptions const&) = delete;
  optional_BatchProcessingOptions(optional_BatchProcessingOptions&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_BatchProcessingOptions& operator=(optional_BatchProcessingOptions&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_BatchProcessingOptions_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_BatchProcessingOptions* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_BatchProcessingOptions* swig_self_;
  bool swig_owns_self_;
};

class Span {
public:
  void SetAttribute(std::string const& key, std::string const& arg3);
  void SetAttribute(std::string const& key, vector_string const & arg3);
  void SetOK();
  void SetError(std::string const& description);
  void End();
  ~Span() {
    if (swig_owns_self_)
      inworld_Span_delete(swig_self_);
  }

  explicit Span(SwigObj_inworld_Span* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Span(Span const&) = delete;
  Span& operator=(Span const&) = delete;
  Span(Span&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Span& operator=(Span&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Span_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Span* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Span* swig_self_;
  bool swig_owns_self_;
};

class SpanDataEvent {
public:
  void name(std::string const& name);
  std::string name() const;
  void timestampInNanos(long long timestampInNanos);
  long long timestampInNanos() const;
  void attributes(map_string_string * attributes);
  map_string_string * attributes() const;
  SpanDataEvent();
  SpanDataEvent(SpanDataEvent const & other);
  ~SpanDataEvent() {
    if (swig_owns_self_)
      inworld_SpanDataEvent_delete(swig_self_);
  }

  explicit SpanDataEvent(SwigObj_inworld_SpanDataEvent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SpanDataEvent& operator=(SpanDataEvent const&) = delete;
  SpanDataEvent(SpanDataEvent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SpanDataEvent& operator=(SpanDataEvent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SpanDataEvent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SpanDataEvent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SpanDataEvent* swig_self_;
  bool swig_owns_self_;
};

class SpanData {
public:
  std::string GetTraceId() const;
  std::string GetSpanId() const;
  std::string GetParentSpanId() const;
  std::string GetName() const;
  std::string GetDescription() const;
  long long GetStartTimeInNanos() const;
  long long GetDurationInNanos() const;
  std::string GetSpanKind() const;
  std::string GetStatus() const;
  map_string_string GetAttributes() const;
  vector_SpanDataEvent GetEvents() const;
  ~SpanData() {
    if (swig_owns_self_)
      inworld_SpanData_delete(swig_self_);
  }

  explicit SpanData(SwigObj_inworld_SpanData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SpanData(SpanData const&) = delete;
  SpanData& operator=(SpanData const&) = delete;
  SpanData(SpanData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SpanData& operator=(SpanData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SpanData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SpanData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SpanData* swig_self_;
  bool swig_owns_self_;
};

class BatchProcessingOptions {
public:
  void max_queue_size(size_t max_queue_size);
  size_t max_queue_size() const;
  void max_export_batch_size(size_t max_export_batch_size);
  size_t max_export_batch_size() const;
  BatchProcessingOptions();
  BatchProcessingOptions(BatchProcessingOptions const & other);
  ~BatchProcessingOptions() {
    if (swig_owns_self_)
      inworld_BatchProcessingOptions_delete(swig_self_);
  }

  explicit BatchProcessingOptions(SwigObj_inworld_BatchProcessingOptions* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  BatchProcessingOptions& operator=(BatchProcessingOptions const&) = delete;
  BatchProcessingOptions(BatchProcessingOptions&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  BatchProcessingOptions& operator=(BatchProcessingOptions&& obj) noexcept {
    if (swig_owns_self_)
      inworld_BatchProcessingOptions_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_BatchProcessingOptions* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_BatchProcessingOptions* swig_self_;
  bool swig_owns_self_;
};

class TracerConfig {
public:
  void sampling_rate(double sampling_rate);
  double sampling_rate() const;
  void span_dump_path(std::string const& span_dump_path);
  std::string span_dump_path() const;
  void batch_processing_opts(optional_BatchProcessingOptions * batch_processing_opts);
  optional_BatchProcessingOptions * batch_processing_opts() const;
  void enable_span_capture(bool enable_span_capture);
  bool enable_span_capture() const;
  void max_queue_size(size_t max_queue_size);
  size_t max_queue_size() const;
  TracerConfig();
  TracerConfig(TracerConfig const & other);
  ~TracerConfig() {
    if (swig_owns_self_)
      inworld_TracerConfig_delete(swig_self_);
  }

  explicit TracerConfig(SwigObj_inworld_TracerConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TracerConfig& operator=(TracerConfig const&) = delete;
  TracerConfig(TracerConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TracerConfig& operator=(TracerConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TracerConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TracerConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TracerConfig* swig_self_;
  bool swig_owns_self_;
};

class LoggerConfig {
public:
  void log_level(LogLevel log_level);
  LogLevel log_level() const;
  void sink_absl_logs(bool sink_absl_logs);
  bool sink_absl_logs() const;
  void batch_processing_opts(optional_BatchProcessingOptions * batch_processing_opts);
  optional_BatchProcessingOptions * batch_processing_opts() const;
  LoggerConfig();
  LoggerConfig(LoggerConfig const & other);
  ~LoggerConfig() {
    if (swig_owns_self_)
      inworld_LoggerConfig_delete(swig_self_);
  }

  explicit LoggerConfig(SwigObj_inworld_LoggerConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LoggerConfig& operator=(LoggerConfig const&) = delete;
  LoggerConfig(LoggerConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LoggerConfig& operator=(LoggerConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LoggerConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LoggerConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LoggerConfig* swig_self_;
  bool swig_owns_self_;
};

class MetricConfig {
public:
  enum class MetricType  {
    kCounterUInt,
    kCounterDouble,
    kGaugeInt,
    kGaugeDouble,
    kHistogramUInt,
    kHistogramDouble
  };

  void metric_type(MetricConfig::MetricType metric_type);
  MetricConfig::MetricType metric_type() const;
  void name(std::string const& name);
  std::string name() const;
  void description(std::string const& description);
  std::string description() const;
  void unit(std::string const& unit);
  std::string unit() const;
  MetricConfig();
  MetricConfig(MetricConfig const & other);
  ~MetricConfig() {
    if (swig_owns_self_)
      inworld_MetricConfig_delete(swig_self_);
  }

  explicit MetricConfig(SwigObj_inworld_MetricConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MetricConfig& operator=(MetricConfig const&) = delete;
  MetricConfig(MetricConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MetricConfig& operator=(MetricConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MetricConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MetricConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MetricConfig* swig_self_;
  bool swig_owns_self_;
};

class TelemetryConfig {
public:
  void tracer(TracerConfig * tracer);
  TracerConfig * tracer() const;
  void logger(LoggerConfig * logger);
  LoggerConfig * logger() const;
  void service_name(std::string const& service_name);
  std::string service_name() const;
  void service_version(std::string const& service_version);
  std::string service_version() const;
  void endpoint(std::string const& endpoint);
  std::string endpoint() const;
  void api_key(std::string const& api_key);
  std::string api_key() const;
  void exporter_type(ExporterType exporter_type);
  ExporterType exporter_type() const;
  void sdk_name(std::string const& sdk_name);
  std::string sdk_name() const;
  void sdk_version(std::string const& sdk_version);
  std::string sdk_version() const;
  TelemetryConfig();
  TelemetryConfig(TelemetryConfig const & other);
  ~TelemetryConfig() {
    if (swig_owns_self_)
      inworld_TelemetryConfig_delete(swig_self_);
  }

  explicit TelemetryConfig(SwigObj_inworld_TelemetryConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TelemetryConfig& operator=(TelemetryConfig const&) = delete;
  TelemetryConfig(TelemetryConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TelemetryConfig& operator=(TelemetryConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TelemetryConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TelemetryConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TelemetryConfig* swig_self_;
  bool swig_owns_self_;
};

class TelemetryConfigBuilder {
public:
  TelemetryConfigBuilder();
  TelemetryConfigBuilder SetServiceName(std::string const& name);
  TelemetryConfigBuilder SetServiceVersion(std::string const& version);
  TelemetryConfigBuilder SetExporterType(ExporterType type);
  TelemetryConfigBuilder SetSdkName(std::string const& name);
  TelemetryConfigBuilder SetSdkVersion(std::string const& version);
  TelemetryConfigBuilder SetEndpoint(std::string const& new_endpoint);
  TelemetryConfigBuilder SetApiKey(std::string const& api_key);
  TelemetryConfigBuilder SetSinkAbslLogs(bool sink_absl_logs);
  TelemetryConfigBuilder SetSamplingRate(double rate);
  TelemetryConfigBuilder SetLogLevel(LogLevel level);
  TelemetryConfigBuilder SetSpanDumpPath(std::string const& path);
  TelemetryConfig Build() const;
  TelemetryConfigBuilder(TelemetryConfigBuilder const & other);
  ~TelemetryConfigBuilder() {
    if (swig_owns_self_)
      inworld_TelemetryConfigBuilder_delete(swig_self_);
  }

  explicit TelemetryConfigBuilder(SwigObj_inworld_TelemetryConfigBuilder* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TelemetryConfigBuilder& operator=(TelemetryConfigBuilder const&) = delete;
  TelemetryConfigBuilder(TelemetryConfigBuilder&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TelemetryConfigBuilder& operator=(TelemetryConfigBuilder&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TelemetryConfigBuilder_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TelemetryConfigBuilder* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TelemetryConfigBuilder* swig_self_;
  bool swig_owns_self_;
};

class vector_TelemetrySpan {
public:
  vector_TelemetrySpan();
  vector_TelemetrySpan(vector_TelemetrySpan const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Span const & x);
  Span get(int i);
  void set(int i, Span const & arg3);
  ~vector_TelemetrySpan() {
    if (swig_owns_self_)
      inworld_vector_TelemetrySpan_delete(swig_self_);
  }

  explicit vector_TelemetrySpan(SwigObj_inworld_vector_TelemetrySpan* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_TelemetrySpan& operator=(vector_TelemetrySpan const&) = delete;
  vector_TelemetrySpan(vector_TelemetrySpan&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_TelemetrySpan& operator=(vector_TelemetrySpan&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_TelemetrySpan_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_TelemetrySpan* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_TelemetrySpan* swig_self_;
  bool swig_owns_self_;
};

class vector_SpanData {
public:
  vector_SpanData();
  vector_SpanData(vector_SpanData const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(SpanData const & x);
  SpanData get(int i);
  void set(int i, SpanData const & arg3);
  ~vector_SpanData() {
    if (swig_owns_self_)
      inworld_vector_SpanData_delete(swig_self_);
  }

  explicit vector_SpanData(SwigObj_inworld_vector_SpanData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_SpanData& operator=(vector_SpanData const&) = delete;
  vector_SpanData(vector_SpanData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_SpanData& operator=(vector_SpanData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_SpanData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_SpanData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_SpanData* swig_self_;
  bool swig_owns_self_;
};

class vector_SpanDataEvent {
public:
  vector_SpanDataEvent();
  vector_SpanDataEvent(vector_SpanDataEvent const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(SpanDataEvent const & x);
  SpanDataEvent get(int i);
  void set(int i, SpanDataEvent const & arg3);
  ~vector_SpanDataEvent() {
    if (swig_owns_self_)
      inworld_vector_SpanDataEvent_delete(swig_self_);
  }

  explicit vector_SpanDataEvent(SwigObj_inworld_vector_SpanDataEvent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_SpanDataEvent& operator=(vector_SpanDataEvent const&) = delete;
  vector_SpanDataEvent(vector_SpanDataEvent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_SpanDataEvent& operator=(vector_SpanDataEvent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_SpanDataEvent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_SpanDataEvent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_SpanDataEvent* swig_self_;
  bool swig_owns_self_;
};

class vector_Edge {
public:
  vector_Edge();
  vector_Edge(vector_Edge const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Edge const & x);
  Edge get(int i);
  void set(int i, Edge const & arg3);
  ~vector_Edge() {
    if (swig_owns_self_)
      inworld_vector_Edge_delete(swig_self_);
  }

  explicit vector_Edge(SwigObj_inworld_vector_Edge* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_Edge& operator=(vector_Edge const&) = delete;
  vector_Edge(vector_Edge&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_Edge& operator=(vector_Edge&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_Edge_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_Edge* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_Edge* swig_self_;
  bool swig_owns_self_;
};

class vector_char {
public:
  vector_char();
  vector_char(vector_char const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(char x);
  char get(int i);
  void set(int i, char arg3);
  ~vector_char() {
    if (swig_owns_self_)
      inworld_vector_char_delete(swig_self_);
  }

  explicit vector_char(SwigObj_inworld_vector_char* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_char& operator=(vector_char const&) = delete;
  vector_char(vector_char&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_char& operator=(vector_char&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_char_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_char* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_char* swig_self_;
  bool swig_owns_self_;
};

class vector_float {
public:
  vector_float();
  vector_float(vector_float const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(float x);
  float get(int i);
  void set(int i, float arg3);
  ~vector_float() {
    if (swig_owns_self_)
      inworld_vector_float_delete(swig_self_);
  }

  explicit vector_float(SwigObj_inworld_vector_float* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_float& operator=(vector_float const&) = delete;
  vector_float(vector_float&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_float& operator=(vector_float&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_float_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_float* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_float* swig_self_;
  bool swig_owns_self_;
};

class TransformationStreamDestructor {
public:
  TransformationStreamDestructor(void * context, void * arg2);
  ~TransformationStreamDestructor() {
    if (swig_owns_self_)
      inworld_TransformationStreamDestructor_delete(swig_self_);
  }
  TransformationStreamDestructor(TransformationStreamDestructor const & other);

  explicit TransformationStreamDestructor(SwigObj_inworld_TransformationStreamDestructor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamDestructor& operator=(TransformationStreamDestructor const&) = delete;
  TransformationStreamDestructor(TransformationStreamDestructor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamDestructor& operator=(TransformationStreamDestructor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamDestructor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamDestructor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamDestructor* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_BaseData_To_string : public InputStream_string {
public:
  static TransformationStream_BaseData_To_string null() { return TransformationStream_BaseData_To_string{(SwigObj_inworld_TransformationStream_BaseData_To_string*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_BaseData_To_string() {
    if (swig_owns_self_) {
      inworld_TransformationStream_BaseData_To_string_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_string Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_string const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_string Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_string const & arg2, TransformationStreamThreadedFilterExecutor_BaseData const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_BaseData_To_string(SwigObj_inworld_TransformationStream_BaseData_To_string* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  TransformationStream_BaseData_To_string(TransformationStream_BaseData_To_string const&) = delete;
  TransformationStream_BaseData_To_string& operator=(TransformationStream_BaseData_To_string const&) = delete;
  TransformationStream_BaseData_To_string(TransformationStream_BaseData_To_string&& obj) = default;
  TransformationStream_BaseData_To_string& operator=(TransformationStream_BaseData_To_string&& obj) = default;
  SwigObj_inworld_TransformationStream_BaseData_To_string* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_BaseData_To_string*)InputStream_string::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_BaseData_To_string {
public:
  TransformationStreamThreadedTransformExecutor_BaseData_To_string(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_BaseData_To_string() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_delete(swig_self_);
  }
  static StatusOr_BaseData GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_string const& arg2);
  TransformationStreamThreadedTransformExecutor_BaseData_To_string(TransformationStreamThreadedTransformExecutor_BaseData_To_string const & other);

  explicit TransformationStreamThreadedTransformExecutor_BaseData_To_string(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_BaseData_To_string& operator=(TransformationStreamThreadedTransformExecutor_BaseData_To_string const&) = delete;
  TransformationStreamThreadedTransformExecutor_BaseData_To_string(TransformationStreamThreadedTransformExecutor_BaseData_To_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_BaseData_To_string& operator=(TransformationStreamThreadedTransformExecutor_BaseData_To_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_BaseData_To_Content : public InputStream_Content {
public:
  static TransformationStream_BaseData_To_Content null() { return TransformationStream_BaseData_To_Content{(SwigObj_inworld_TransformationStream_BaseData_To_Content*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_BaseData_To_Content() {
    if (swig_owns_self_) {
      inworld_TransformationStream_BaseData_To_Content_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_Content Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_Content const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_Content Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_Content const & arg2, TransformationStreamThreadedFilterExecutor_BaseData const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_BaseData_To_Content(SwigObj_inworld_TransformationStream_BaseData_To_Content* swig_self, bool swig_owns_self = true) noexcept : InputStream_Content{(SwigObj_inworld_InputStream_Content*)swig_self, swig_owns_self} {}
  TransformationStream_BaseData_To_Content(TransformationStream_BaseData_To_Content const&) = delete;
  TransformationStream_BaseData_To_Content& operator=(TransformationStream_BaseData_To_Content const&) = delete;
  TransformationStream_BaseData_To_Content(TransformationStream_BaseData_To_Content&& obj) = default;
  TransformationStream_BaseData_To_Content& operator=(TransformationStream_BaseData_To_Content&& obj) = default;
  SwigObj_inworld_TransformationStream_BaseData_To_Content* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_BaseData_To_Content*)InputStream_Content::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_BaseData_To_Content {
public:
  TransformationStreamThreadedTransformExecutor_BaseData_To_Content(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_BaseData_To_Content() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_delete(swig_self_);
  }
  static StatusOr_BaseData GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_Content const& arg2);
  TransformationStreamThreadedTransformExecutor_BaseData_To_Content(TransformationStreamThreadedTransformExecutor_BaseData_To_Content const & other);

  explicit TransformationStreamThreadedTransformExecutor_BaseData_To_Content(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_BaseData_To_Content& operator=(TransformationStreamThreadedTransformExecutor_BaseData_To_Content const&) = delete;
  TransformationStreamThreadedTransformExecutor_BaseData_To_Content(TransformationStreamThreadedTransformExecutor_BaseData_To_Content&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_BaseData_To_Content& operator=(TransformationStreamThreadedTransformExecutor_BaseData_To_Content&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_BaseData_To_AudioChunk : public InputStream_AudioChunk {
public:
  static TransformationStream_BaseData_To_AudioChunk null() { return TransformationStream_BaseData_To_AudioChunk{(SwigObj_inworld_TransformationStream_BaseData_To_AudioChunk*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_BaseData_To_AudioChunk() {
    if (swig_owns_self_) {
      inworld_TransformationStream_BaseData_To_AudioChunk_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_AudioChunk Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_AudioChunk Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk const & arg2, TransformationStreamThreadedFilterExecutor_BaseData const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_BaseData_To_AudioChunk(SwigObj_inworld_TransformationStream_BaseData_To_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : InputStream_AudioChunk{(SwigObj_inworld_InputStream_AudioChunk*)swig_self, swig_owns_self} {}
  TransformationStream_BaseData_To_AudioChunk(TransformationStream_BaseData_To_AudioChunk const&) = delete;
  TransformationStream_BaseData_To_AudioChunk& operator=(TransformationStream_BaseData_To_AudioChunk const&) = delete;
  TransformationStream_BaseData_To_AudioChunk(TransformationStream_BaseData_To_AudioChunk&& obj) = default;
  TransformationStream_BaseData_To_AudioChunk& operator=(TransformationStream_BaseData_To_AudioChunk&& obj) = default;
  SwigObj_inworld_TransformationStream_BaseData_To_AudioChunk* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_BaseData_To_AudioChunk*)InputStream_AudioChunk::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk {
public:
  TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_delete(swig_self_);
  }
  static StatusOr_BaseData GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_AudioChunk const& arg2);
  TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk(TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk const & other);

  explicit TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk& operator=(TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk const&) = delete;
  TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk(TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk& operator=(TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_BaseData_To_TTSOutput : public InputStream_TTSOutput {
public:
  static TransformationStream_BaseData_To_TTSOutput null() { return TransformationStream_BaseData_To_TTSOutput{(SwigObj_inworld_TransformationStream_BaseData_To_TTSOutput*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_BaseData_To_TTSOutput() {
    if (swig_owns_self_) {
      inworld_TransformationStream_BaseData_To_TTSOutput_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_TTSOutput Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_TTSOutput Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput const & arg2, TransformationStreamThreadedFilterExecutor_BaseData const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_BaseData_To_TTSOutput(SwigObj_inworld_TransformationStream_BaseData_To_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : InputStream_TTSOutput{(SwigObj_inworld_InputStream_TTSOutput*)swig_self, swig_owns_self} {}
  TransformationStream_BaseData_To_TTSOutput(TransformationStream_BaseData_To_TTSOutput const&) = delete;
  TransformationStream_BaseData_To_TTSOutput& operator=(TransformationStream_BaseData_To_TTSOutput const&) = delete;
  TransformationStream_BaseData_To_TTSOutput(TransformationStream_BaseData_To_TTSOutput&& obj) = default;
  TransformationStream_BaseData_To_TTSOutput& operator=(TransformationStream_BaseData_To_TTSOutput&& obj) = default;
  SwigObj_inworld_TransformationStream_BaseData_To_TTSOutput* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_BaseData_To_TTSOutput*)InputStream_TTSOutput::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput {
public:
  TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_delete(swig_self_);
  }
  static StatusOr_BaseData GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_TTSOutput const& arg2);
  TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput(TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput const & other);

  explicit TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput& operator=(TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput const&) = delete;
  TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput(TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput& operator=(TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_BaseData_To_BaseData : public InputStream_BaseData {
public:
  static TransformationStream_BaseData_To_BaseData null() { return TransformationStream_BaseData_To_BaseData{(SwigObj_inworld_TransformationStream_BaseData_To_BaseData*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_BaseData_To_BaseData() {
    if (swig_owns_self_) {
      inworld_TransformationStream_BaseData_To_BaseData_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_BaseData Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_BaseData Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData const & arg2, TransformationStreamThreadedFilterExecutor_BaseData const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_BaseData_To_BaseData(SwigObj_inworld_TransformationStream_BaseData_To_BaseData* swig_self, bool swig_owns_self = true) noexcept : InputStream_BaseData{(SwigObj_inworld_InputStream_BaseData*)swig_self, swig_owns_self} {}
  TransformationStream_BaseData_To_BaseData(TransformationStream_BaseData_To_BaseData const&) = delete;
  TransformationStream_BaseData_To_BaseData& operator=(TransformationStream_BaseData_To_BaseData const&) = delete;
  TransformationStream_BaseData_To_BaseData(TransformationStream_BaseData_To_BaseData&& obj) = default;
  TransformationStream_BaseData_To_BaseData& operator=(TransformationStream_BaseData_To_BaseData&& obj) = default;
  SwigObj_inworld_TransformationStream_BaseData_To_BaseData* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_BaseData_To_BaseData*)InputStream_BaseData::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData {
public:
  TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_delete(swig_self_);
  }
  static StatusOr_BaseData GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_BaseData const& arg2);
  TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData(TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData const & other);

  explicit TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData& operator=(TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData const&) = delete;
  TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData(TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData& operator=(TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_string_To_Content : public InputStream_Content {
public:
  static TransformationStream_string_To_Content null() { return TransformationStream_string_To_Content{(SwigObj_inworld_TransformationStream_string_To_Content*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_string_To_Content() {
    if (swig_owns_self_) {
      inworld_TransformationStream_string_To_Content_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_Content Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_Content const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_Content Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_Content const & arg2, TransformationStreamThreadedFilterExecutor_string const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_string_To_Content(SwigObj_inworld_TransformationStream_string_To_Content* swig_self, bool swig_owns_self = true) noexcept : InputStream_Content{(SwigObj_inworld_InputStream_Content*)swig_self, swig_owns_self} {}
  TransformationStream_string_To_Content(TransformationStream_string_To_Content const&) = delete;
  TransformationStream_string_To_Content& operator=(TransformationStream_string_To_Content const&) = delete;
  TransformationStream_string_To_Content(TransformationStream_string_To_Content&& obj) = default;
  TransformationStream_string_To_Content& operator=(TransformationStream_string_To_Content&& obj) = default;
  SwigObj_inworld_TransformationStream_string_To_Content* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_string_To_Content*)InputStream_Content::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_string_To_Content {
public:
  TransformationStreamThreadedTransformExecutor_string_To_Content(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_string_To_Content() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_delete(swig_self_);
  }
  static StatusOr_string GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_Content const& arg2);
  TransformationStreamThreadedTransformExecutor_string_To_Content(TransformationStreamThreadedTransformExecutor_string_To_Content const & other);

  explicit TransformationStreamThreadedTransformExecutor_string_To_Content(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_Content* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_string_To_Content& operator=(TransformationStreamThreadedTransformExecutor_string_To_Content const&) = delete;
  TransformationStreamThreadedTransformExecutor_string_To_Content(TransformationStreamThreadedTransformExecutor_string_To_Content&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_string_To_Content& operator=(TransformationStreamThreadedTransformExecutor_string_To_Content&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_Content* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_Content* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_string_To_AudioChunk : public InputStream_AudioChunk {
public:
  static TransformationStream_string_To_AudioChunk null() { return TransformationStream_string_To_AudioChunk{(SwigObj_inworld_TransformationStream_string_To_AudioChunk*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_string_To_AudioChunk() {
    if (swig_owns_self_) {
      inworld_TransformationStream_string_To_AudioChunk_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_AudioChunk Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_AudioChunk const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_AudioChunk Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_AudioChunk const & arg2, TransformationStreamThreadedFilterExecutor_string const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_string_To_AudioChunk(SwigObj_inworld_TransformationStream_string_To_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : InputStream_AudioChunk{(SwigObj_inworld_InputStream_AudioChunk*)swig_self, swig_owns_self} {}
  TransformationStream_string_To_AudioChunk(TransformationStream_string_To_AudioChunk const&) = delete;
  TransformationStream_string_To_AudioChunk& operator=(TransformationStream_string_To_AudioChunk const&) = delete;
  TransformationStream_string_To_AudioChunk(TransformationStream_string_To_AudioChunk&& obj) = default;
  TransformationStream_string_To_AudioChunk& operator=(TransformationStream_string_To_AudioChunk&& obj) = default;
  SwigObj_inworld_TransformationStream_string_To_AudioChunk* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_string_To_AudioChunk*)InputStream_AudioChunk::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_string_To_AudioChunk {
public:
  TransformationStreamThreadedTransformExecutor_string_To_AudioChunk(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_string_To_AudioChunk() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_delete(swig_self_);
  }
  static StatusOr_string GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_AudioChunk const& arg2);
  TransformationStreamThreadedTransformExecutor_string_To_AudioChunk(TransformationStreamThreadedTransformExecutor_string_To_AudioChunk const & other);

  explicit TransformationStreamThreadedTransformExecutor_string_To_AudioChunk(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_string_To_AudioChunk& operator=(TransformationStreamThreadedTransformExecutor_string_To_AudioChunk const&) = delete;
  TransformationStreamThreadedTransformExecutor_string_To_AudioChunk(TransformationStreamThreadedTransformExecutor_string_To_AudioChunk&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_string_To_AudioChunk& operator=(TransformationStreamThreadedTransformExecutor_string_To_AudioChunk&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_string_To_TTSOutput : public InputStream_TTSOutput {
public:
  static TransformationStream_string_To_TTSOutput null() { return TransformationStream_string_To_TTSOutput{(SwigObj_inworld_TransformationStream_string_To_TTSOutput*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_string_To_TTSOutput() {
    if (swig_owns_self_) {
      inworld_TransformationStream_string_To_TTSOutput_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_TTSOutput Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_TTSOutput const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_TTSOutput Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_TTSOutput const & arg2, TransformationStreamThreadedFilterExecutor_string const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_string_To_TTSOutput(SwigObj_inworld_TransformationStream_string_To_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : InputStream_TTSOutput{(SwigObj_inworld_InputStream_TTSOutput*)swig_self, swig_owns_self} {}
  TransformationStream_string_To_TTSOutput(TransformationStream_string_To_TTSOutput const&) = delete;
  TransformationStream_string_To_TTSOutput& operator=(TransformationStream_string_To_TTSOutput const&) = delete;
  TransformationStream_string_To_TTSOutput(TransformationStream_string_To_TTSOutput&& obj) = default;
  TransformationStream_string_To_TTSOutput& operator=(TransformationStream_string_To_TTSOutput&& obj) = default;
  SwigObj_inworld_TransformationStream_string_To_TTSOutput* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_string_To_TTSOutput*)InputStream_TTSOutput::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_string_To_TTSOutput {
public:
  TransformationStreamThreadedTransformExecutor_string_To_TTSOutput(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_string_To_TTSOutput() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_delete(swig_self_);
  }
  static StatusOr_string GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_TTSOutput const& arg2);
  TransformationStreamThreadedTransformExecutor_string_To_TTSOutput(TransformationStreamThreadedTransformExecutor_string_To_TTSOutput const & other);

  explicit TransformationStreamThreadedTransformExecutor_string_To_TTSOutput(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_string_To_TTSOutput& operator=(TransformationStreamThreadedTransformExecutor_string_To_TTSOutput const&) = delete;
  TransformationStreamThreadedTransformExecutor_string_To_TTSOutput(TransformationStreamThreadedTransformExecutor_string_To_TTSOutput&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_string_To_TTSOutput& operator=(TransformationStreamThreadedTransformExecutor_string_To_TTSOutput&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_string_To_BaseData : public InputStream_BaseData {
public:
  static TransformationStream_string_To_BaseData null() { return TransformationStream_string_To_BaseData{(SwigObj_inworld_TransformationStream_string_To_BaseData*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_string_To_BaseData() {
    if (swig_owns_self_) {
      inworld_TransformationStream_string_To_BaseData_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_BaseData Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_BaseData const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_BaseData Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_BaseData const & arg2, TransformationStreamThreadedFilterExecutor_string const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_string_To_BaseData(SwigObj_inworld_TransformationStream_string_To_BaseData* swig_self, bool swig_owns_self = true) noexcept : InputStream_BaseData{(SwigObj_inworld_InputStream_BaseData*)swig_self, swig_owns_self} {}
  TransformationStream_string_To_BaseData(TransformationStream_string_To_BaseData const&) = delete;
  TransformationStream_string_To_BaseData& operator=(TransformationStream_string_To_BaseData const&) = delete;
  TransformationStream_string_To_BaseData(TransformationStream_string_To_BaseData&& obj) = default;
  TransformationStream_string_To_BaseData& operator=(TransformationStream_string_To_BaseData&& obj) = default;
  SwigObj_inworld_TransformationStream_string_To_BaseData* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_string_To_BaseData*)InputStream_BaseData::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_string_To_BaseData {
public:
  TransformationStreamThreadedTransformExecutor_string_To_BaseData(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_string_To_BaseData() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_delete(swig_self_);
  }
  static StatusOr_string GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_BaseData const& arg2);
  TransformationStreamThreadedTransformExecutor_string_To_BaseData(TransformationStreamThreadedTransformExecutor_string_To_BaseData const & other);

  explicit TransformationStreamThreadedTransformExecutor_string_To_BaseData(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_string_To_BaseData& operator=(TransformationStreamThreadedTransformExecutor_string_To_BaseData const&) = delete;
  TransformationStreamThreadedTransformExecutor_string_To_BaseData(TransformationStreamThreadedTransformExecutor_string_To_BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_string_To_BaseData& operator=(TransformationStreamThreadedTransformExecutor_string_To_BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_string_To_string : public InputStream_string {
public:
  static TransformationStream_string_To_string null() { return TransformationStream_string_To_string{(SwigObj_inworld_TransformationStream_string_To_string*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_string_To_string() {
    if (swig_owns_self_) {
      inworld_TransformationStream_string_To_string_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_string Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_string const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_string Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_string const & arg2, TransformationStreamThreadedFilterExecutor_string const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_string_To_string(SwigObj_inworld_TransformationStream_string_To_string* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  TransformationStream_string_To_string(TransformationStream_string_To_string const&) = delete;
  TransformationStream_string_To_string& operator=(TransformationStream_string_To_string const&) = delete;
  TransformationStream_string_To_string(TransformationStream_string_To_string&& obj) = default;
  TransformationStream_string_To_string& operator=(TransformationStream_string_To_string&& obj) = default;
  SwigObj_inworld_TransformationStream_string_To_string* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_string_To_string*)InputStream_string::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_string_To_string {
public:
  TransformationStreamThreadedTransformExecutor_string_To_string(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_string_To_string() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_string_To_string_delete(swig_self_);
  }
  static StatusOr_string GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_string const& arg2);
  TransformationStreamThreadedTransformExecutor_string_To_string(TransformationStreamThreadedTransformExecutor_string_To_string const & other);

  explicit TransformationStreamThreadedTransformExecutor_string_To_string(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_string_To_string& operator=(TransformationStreamThreadedTransformExecutor_string_To_string const&) = delete;
  TransformationStreamThreadedTransformExecutor_string_To_string(TransformationStreamThreadedTransformExecutor_string_To_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_string_To_string& operator=(TransformationStreamThreadedTransformExecutor_string_To_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_string_To_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_string_To_string* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_Content_To_string : public InputStream_string {
public:
  static TransformationStream_Content_To_string null() { return TransformationStream_Content_To_string{(SwigObj_inworld_TransformationStream_Content_To_string*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_Content_To_string() {
    if (swig_owns_self_) {
      inworld_TransformationStream_Content_To_string_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_string Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_string const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_string Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_string const & arg2, TransformationStreamThreadedFilterExecutor_Content const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_Content_To_string(SwigObj_inworld_TransformationStream_Content_To_string* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  TransformationStream_Content_To_string(TransformationStream_Content_To_string const&) = delete;
  TransformationStream_Content_To_string& operator=(TransformationStream_Content_To_string const&) = delete;
  TransformationStream_Content_To_string(TransformationStream_Content_To_string&& obj) = default;
  TransformationStream_Content_To_string& operator=(TransformationStream_Content_To_string&& obj) = default;
  SwigObj_inworld_TransformationStream_Content_To_string* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_Content_To_string*)InputStream_string::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_Content_To_string {
public:
  TransformationStreamThreadedTransformExecutor_Content_To_string(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_Content_To_string() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_delete(swig_self_);
  }
  static StatusOr_Content GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_string const& arg2);
  TransformationStreamThreadedTransformExecutor_Content_To_string(TransformationStreamThreadedTransformExecutor_Content_To_string const & other);

  explicit TransformationStreamThreadedTransformExecutor_Content_To_string(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_Content_To_string& operator=(TransformationStreamThreadedTransformExecutor_Content_To_string const&) = delete;
  TransformationStreamThreadedTransformExecutor_Content_To_string(TransformationStreamThreadedTransformExecutor_Content_To_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_Content_To_string& operator=(TransformationStreamThreadedTransformExecutor_Content_To_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_string* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_Content_To_AudioChunk : public InputStream_AudioChunk {
public:
  static TransformationStream_Content_To_AudioChunk null() { return TransformationStream_Content_To_AudioChunk{(SwigObj_inworld_TransformationStream_Content_To_AudioChunk*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_Content_To_AudioChunk() {
    if (swig_owns_self_) {
      inworld_TransformationStream_Content_To_AudioChunk_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_AudioChunk Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_AudioChunk Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk const & arg2, TransformationStreamThreadedFilterExecutor_Content const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_Content_To_AudioChunk(SwigObj_inworld_TransformationStream_Content_To_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : InputStream_AudioChunk{(SwigObj_inworld_InputStream_AudioChunk*)swig_self, swig_owns_self} {}
  TransformationStream_Content_To_AudioChunk(TransformationStream_Content_To_AudioChunk const&) = delete;
  TransformationStream_Content_To_AudioChunk& operator=(TransformationStream_Content_To_AudioChunk const&) = delete;
  TransformationStream_Content_To_AudioChunk(TransformationStream_Content_To_AudioChunk&& obj) = default;
  TransformationStream_Content_To_AudioChunk& operator=(TransformationStream_Content_To_AudioChunk&& obj) = default;
  SwigObj_inworld_TransformationStream_Content_To_AudioChunk* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_Content_To_AudioChunk*)InputStream_AudioChunk::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk {
public:
  TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_delete(swig_self_);
  }
  static StatusOr_Content GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_AudioChunk const& arg2);
  TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk(TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk const & other);

  explicit TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk& operator=(TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk const&) = delete;
  TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk(TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk& operator=(TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_Content_To_TTSOutput : public InputStream_TTSOutput {
public:
  static TransformationStream_Content_To_TTSOutput null() { return TransformationStream_Content_To_TTSOutput{(SwigObj_inworld_TransformationStream_Content_To_TTSOutput*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_Content_To_TTSOutput() {
    if (swig_owns_self_) {
      inworld_TransformationStream_Content_To_TTSOutput_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_TTSOutput Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_TTSOutput Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput const & arg2, TransformationStreamThreadedFilterExecutor_Content const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_Content_To_TTSOutput(SwigObj_inworld_TransformationStream_Content_To_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : InputStream_TTSOutput{(SwigObj_inworld_InputStream_TTSOutput*)swig_self, swig_owns_self} {}
  TransformationStream_Content_To_TTSOutput(TransformationStream_Content_To_TTSOutput const&) = delete;
  TransformationStream_Content_To_TTSOutput& operator=(TransformationStream_Content_To_TTSOutput const&) = delete;
  TransformationStream_Content_To_TTSOutput(TransformationStream_Content_To_TTSOutput&& obj) = default;
  TransformationStream_Content_To_TTSOutput& operator=(TransformationStream_Content_To_TTSOutput&& obj) = default;
  SwigObj_inworld_TransformationStream_Content_To_TTSOutput* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_Content_To_TTSOutput*)InputStream_TTSOutput::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput {
public:
  TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_delete(swig_self_);
  }
  static StatusOr_Content GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_TTSOutput const& arg2);
  TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput(TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput const & other);

  explicit TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput& operator=(TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput const&) = delete;
  TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput(TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput& operator=(TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_Content_To_BaseData : public InputStream_BaseData {
public:
  static TransformationStream_Content_To_BaseData null() { return TransformationStream_Content_To_BaseData{(SwigObj_inworld_TransformationStream_Content_To_BaseData*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_Content_To_BaseData() {
    if (swig_owns_self_) {
      inworld_TransformationStream_Content_To_BaseData_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_BaseData Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_BaseData const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_BaseData Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_BaseData const & arg2, TransformationStreamThreadedFilterExecutor_Content const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_Content_To_BaseData(SwigObj_inworld_TransformationStream_Content_To_BaseData* swig_self, bool swig_owns_self = true) noexcept : InputStream_BaseData{(SwigObj_inworld_InputStream_BaseData*)swig_self, swig_owns_self} {}
  TransformationStream_Content_To_BaseData(TransformationStream_Content_To_BaseData const&) = delete;
  TransformationStream_Content_To_BaseData& operator=(TransformationStream_Content_To_BaseData const&) = delete;
  TransformationStream_Content_To_BaseData(TransformationStream_Content_To_BaseData&& obj) = default;
  TransformationStream_Content_To_BaseData& operator=(TransformationStream_Content_To_BaseData&& obj) = default;
  SwigObj_inworld_TransformationStream_Content_To_BaseData* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_Content_To_BaseData*)InputStream_BaseData::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_Content_To_BaseData {
public:
  TransformationStreamThreadedTransformExecutor_Content_To_BaseData(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_Content_To_BaseData() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_delete(swig_self_);
  }
  static StatusOr_Content GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_BaseData const& arg2);
  TransformationStreamThreadedTransformExecutor_Content_To_BaseData(TransformationStreamThreadedTransformExecutor_Content_To_BaseData const & other);

  explicit TransformationStreamThreadedTransformExecutor_Content_To_BaseData(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_Content_To_BaseData& operator=(TransformationStreamThreadedTransformExecutor_Content_To_BaseData const&) = delete;
  TransformationStreamThreadedTransformExecutor_Content_To_BaseData(TransformationStreamThreadedTransformExecutor_Content_To_BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_Content_To_BaseData& operator=(TransformationStreamThreadedTransformExecutor_Content_To_BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_Content_To_Content : public InputStream_Content {
public:
  static TransformationStream_Content_To_Content null() { return TransformationStream_Content_To_Content{(SwigObj_inworld_TransformationStream_Content_To_Content*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_Content_To_Content() {
    if (swig_owns_self_) {
      inworld_TransformationStream_Content_To_Content_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_Content Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_Content const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_Content Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_Content const & arg2, TransformationStreamThreadedFilterExecutor_Content const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_Content_To_Content(SwigObj_inworld_TransformationStream_Content_To_Content* swig_self, bool swig_owns_self = true) noexcept : InputStream_Content{(SwigObj_inworld_InputStream_Content*)swig_self, swig_owns_self} {}
  TransformationStream_Content_To_Content(TransformationStream_Content_To_Content const&) = delete;
  TransformationStream_Content_To_Content& operator=(TransformationStream_Content_To_Content const&) = delete;
  TransformationStream_Content_To_Content(TransformationStream_Content_To_Content&& obj) = default;
  TransformationStream_Content_To_Content& operator=(TransformationStream_Content_To_Content&& obj) = default;
  SwigObj_inworld_TransformationStream_Content_To_Content* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_Content_To_Content*)InputStream_Content::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_Content_To_Content {
public:
  TransformationStreamThreadedTransformExecutor_Content_To_Content(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_Content_To_Content() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_delete(swig_self_);
  }
  static StatusOr_Content GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_Content const& arg2);
  TransformationStreamThreadedTransformExecutor_Content_To_Content(TransformationStreamThreadedTransformExecutor_Content_To_Content const & other);

  explicit TransformationStreamThreadedTransformExecutor_Content_To_Content(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_Content_To_Content& operator=(TransformationStreamThreadedTransformExecutor_Content_To_Content const&) = delete;
  TransformationStreamThreadedTransformExecutor_Content_To_Content(TransformationStreamThreadedTransformExecutor_Content_To_Content&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_Content_To_Content& operator=(TransformationStreamThreadedTransformExecutor_Content_To_Content&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_AudioChunk_To_string : public InputStream_string {
public:
  static TransformationStream_AudioChunk_To_string null() { return TransformationStream_AudioChunk_To_string{(SwigObj_inworld_TransformationStream_AudioChunk_To_string*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_AudioChunk_To_string() {
    if (swig_owns_self_) {
      inworld_TransformationStream_AudioChunk_To_string_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_string Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_string const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_string Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_string const & arg2, TransformationStreamThreadedFilterExecutor_AudioChunk const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_AudioChunk_To_string(SwigObj_inworld_TransformationStream_AudioChunk_To_string* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  TransformationStream_AudioChunk_To_string(TransformationStream_AudioChunk_To_string const&) = delete;
  TransformationStream_AudioChunk_To_string& operator=(TransformationStream_AudioChunk_To_string const&) = delete;
  TransformationStream_AudioChunk_To_string(TransformationStream_AudioChunk_To_string&& obj) = default;
  TransformationStream_AudioChunk_To_string& operator=(TransformationStream_AudioChunk_To_string&& obj) = default;
  SwigObj_inworld_TransformationStream_AudioChunk_To_string* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_AudioChunk_To_string*)InputStream_string::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_AudioChunk_To_string {
public:
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_string(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_AudioChunk_To_string() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_delete(swig_self_);
  }
  static StatusOr_AudioChunk GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_string const& arg2);
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_string(TransformationStreamThreadedTransformExecutor_AudioChunk_To_string const & other);

  explicit TransformationStreamThreadedTransformExecutor_AudioChunk_To_string(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_string& operator=(TransformationStreamThreadedTransformExecutor_AudioChunk_To_string const&) = delete;
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_string(TransformationStreamThreadedTransformExecutor_AudioChunk_To_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_string& operator=(TransformationStreamThreadedTransformExecutor_AudioChunk_To_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_AudioChunk_To_Content : public InputStream_Content {
public:
  static TransformationStream_AudioChunk_To_Content null() { return TransformationStream_AudioChunk_To_Content{(SwigObj_inworld_TransformationStream_AudioChunk_To_Content*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_AudioChunk_To_Content() {
    if (swig_owns_self_) {
      inworld_TransformationStream_AudioChunk_To_Content_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_Content Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_Content Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content const & arg2, TransformationStreamThreadedFilterExecutor_AudioChunk const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_AudioChunk_To_Content(SwigObj_inworld_TransformationStream_AudioChunk_To_Content* swig_self, bool swig_owns_self = true) noexcept : InputStream_Content{(SwigObj_inworld_InputStream_Content*)swig_self, swig_owns_self} {}
  TransformationStream_AudioChunk_To_Content(TransformationStream_AudioChunk_To_Content const&) = delete;
  TransformationStream_AudioChunk_To_Content& operator=(TransformationStream_AudioChunk_To_Content const&) = delete;
  TransformationStream_AudioChunk_To_Content(TransformationStream_AudioChunk_To_Content&& obj) = default;
  TransformationStream_AudioChunk_To_Content& operator=(TransformationStream_AudioChunk_To_Content&& obj) = default;
  SwigObj_inworld_TransformationStream_AudioChunk_To_Content* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_AudioChunk_To_Content*)InputStream_Content::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content {
public:
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_delete(swig_self_);
  }
  static StatusOr_AudioChunk GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_Content const& arg2);
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content(TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content const & other);

  explicit TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content& operator=(TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content const&) = delete;
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content(TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content& operator=(TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_AudioChunk_To_TTSOutput : public InputStream_TTSOutput {
public:
  static TransformationStream_AudioChunk_To_TTSOutput null() { return TransformationStream_AudioChunk_To_TTSOutput{(SwigObj_inworld_TransformationStream_AudioChunk_To_TTSOutput*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_AudioChunk_To_TTSOutput() {
    if (swig_owns_self_) {
      inworld_TransformationStream_AudioChunk_To_TTSOutput_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_TTSOutput Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_TTSOutput Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput const & arg2, TransformationStreamThreadedFilterExecutor_AudioChunk const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_AudioChunk_To_TTSOutput(SwigObj_inworld_TransformationStream_AudioChunk_To_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : InputStream_TTSOutput{(SwigObj_inworld_InputStream_TTSOutput*)swig_self, swig_owns_self} {}
  TransformationStream_AudioChunk_To_TTSOutput(TransformationStream_AudioChunk_To_TTSOutput const&) = delete;
  TransformationStream_AudioChunk_To_TTSOutput& operator=(TransformationStream_AudioChunk_To_TTSOutput const&) = delete;
  TransformationStream_AudioChunk_To_TTSOutput(TransformationStream_AudioChunk_To_TTSOutput&& obj) = default;
  TransformationStream_AudioChunk_To_TTSOutput& operator=(TransformationStream_AudioChunk_To_TTSOutput&& obj) = default;
  SwigObj_inworld_TransformationStream_AudioChunk_To_TTSOutput* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_AudioChunk_To_TTSOutput*)InputStream_TTSOutput::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput {
public:
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_delete(swig_self_);
  }
  static StatusOr_AudioChunk GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_TTSOutput const& arg2);
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput(TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput const & other);

  explicit TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput& operator=(TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput const&) = delete;
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput(TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput& operator=(TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_AudioChunk_To_BaseData : public InputStream_BaseData {
public:
  static TransformationStream_AudioChunk_To_BaseData null() { return TransformationStream_AudioChunk_To_BaseData{(SwigObj_inworld_TransformationStream_AudioChunk_To_BaseData*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_AudioChunk_To_BaseData() {
    if (swig_owns_self_) {
      inworld_TransformationStream_AudioChunk_To_BaseData_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_BaseData Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_BaseData Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData const & arg2, TransformationStreamThreadedFilterExecutor_AudioChunk const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_AudioChunk_To_BaseData(SwigObj_inworld_TransformationStream_AudioChunk_To_BaseData* swig_self, bool swig_owns_self = true) noexcept : InputStream_BaseData{(SwigObj_inworld_InputStream_BaseData*)swig_self, swig_owns_self} {}
  TransformationStream_AudioChunk_To_BaseData(TransformationStream_AudioChunk_To_BaseData const&) = delete;
  TransformationStream_AudioChunk_To_BaseData& operator=(TransformationStream_AudioChunk_To_BaseData const&) = delete;
  TransformationStream_AudioChunk_To_BaseData(TransformationStream_AudioChunk_To_BaseData&& obj) = default;
  TransformationStream_AudioChunk_To_BaseData& operator=(TransformationStream_AudioChunk_To_BaseData&& obj) = default;
  SwigObj_inworld_TransformationStream_AudioChunk_To_BaseData* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_AudioChunk_To_BaseData*)InputStream_BaseData::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData {
public:
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_delete(swig_self_);
  }
  static StatusOr_AudioChunk GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_BaseData const& arg2);
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData(TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData const & other);

  explicit TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData& operator=(TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData const&) = delete;
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData(TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData& operator=(TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_AudioChunk_To_AudioChunk : public InputStream_AudioChunk {
public:
  static TransformationStream_AudioChunk_To_AudioChunk null() { return TransformationStream_AudioChunk_To_AudioChunk{(SwigObj_inworld_TransformationStream_AudioChunk_To_AudioChunk*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_AudioChunk_To_AudioChunk() {
    if (swig_owns_self_) {
      inworld_TransformationStream_AudioChunk_To_AudioChunk_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_AudioChunk Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_AudioChunk Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk const & arg2, TransformationStreamThreadedFilterExecutor_AudioChunk const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_AudioChunk_To_AudioChunk(SwigObj_inworld_TransformationStream_AudioChunk_To_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : InputStream_AudioChunk{(SwigObj_inworld_InputStream_AudioChunk*)swig_self, swig_owns_self} {}
  TransformationStream_AudioChunk_To_AudioChunk(TransformationStream_AudioChunk_To_AudioChunk const&) = delete;
  TransformationStream_AudioChunk_To_AudioChunk& operator=(TransformationStream_AudioChunk_To_AudioChunk const&) = delete;
  TransformationStream_AudioChunk_To_AudioChunk(TransformationStream_AudioChunk_To_AudioChunk&& obj) = default;
  TransformationStream_AudioChunk_To_AudioChunk& operator=(TransformationStream_AudioChunk_To_AudioChunk&& obj) = default;
  SwigObj_inworld_TransformationStream_AudioChunk_To_AudioChunk* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_AudioChunk_To_AudioChunk*)InputStream_AudioChunk::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk {
public:
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_delete(swig_self_);
  }
  static StatusOr_AudioChunk GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_AudioChunk const& arg2);
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk(TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk const & other);

  explicit TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk& operator=(TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk const&) = delete;
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk(TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk& operator=(TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_TTSOutput_To_string : public InputStream_string {
public:
  static TransformationStream_TTSOutput_To_string null() { return TransformationStream_TTSOutput_To_string{(SwigObj_inworld_TransformationStream_TTSOutput_To_string*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_TTSOutput_To_string() {
    if (swig_owns_self_) {
      inworld_TransformationStream_TTSOutput_To_string_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_string Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_string const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_string Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_string const & arg2, TransformationStreamThreadedFilterExecutor_TTSOutput const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_TTSOutput_To_string(SwigObj_inworld_TransformationStream_TTSOutput_To_string* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  TransformationStream_TTSOutput_To_string(TransformationStream_TTSOutput_To_string const&) = delete;
  TransformationStream_TTSOutput_To_string& operator=(TransformationStream_TTSOutput_To_string const&) = delete;
  TransformationStream_TTSOutput_To_string(TransformationStream_TTSOutput_To_string&& obj) = default;
  TransformationStream_TTSOutput_To_string& operator=(TransformationStream_TTSOutput_To_string&& obj) = default;
  SwigObj_inworld_TransformationStream_TTSOutput_To_string* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_TTSOutput_To_string*)InputStream_string::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_TTSOutput_To_string {
public:
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_string(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_TTSOutput_To_string() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_delete(swig_self_);
  }
  static StatusOr_TTSOutput GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_string const& arg2);
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_string(TransformationStreamThreadedTransformExecutor_TTSOutput_To_string const & other);

  explicit TransformationStreamThreadedTransformExecutor_TTSOutput_To_string(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_string& operator=(TransformationStreamThreadedTransformExecutor_TTSOutput_To_string const&) = delete;
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_string(TransformationStreamThreadedTransformExecutor_TTSOutput_To_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_string& operator=(TransformationStreamThreadedTransformExecutor_TTSOutput_To_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_TTSOutput_To_Content : public InputStream_Content {
public:
  static TransformationStream_TTSOutput_To_Content null() { return TransformationStream_TTSOutput_To_Content{(SwigObj_inworld_TransformationStream_TTSOutput_To_Content*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_TTSOutput_To_Content() {
    if (swig_owns_self_) {
      inworld_TransformationStream_TTSOutput_To_Content_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_Content Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_Content Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content const & arg2, TransformationStreamThreadedFilterExecutor_TTSOutput const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_TTSOutput_To_Content(SwigObj_inworld_TransformationStream_TTSOutput_To_Content* swig_self, bool swig_owns_self = true) noexcept : InputStream_Content{(SwigObj_inworld_InputStream_Content*)swig_self, swig_owns_self} {}
  TransformationStream_TTSOutput_To_Content(TransformationStream_TTSOutput_To_Content const&) = delete;
  TransformationStream_TTSOutput_To_Content& operator=(TransformationStream_TTSOutput_To_Content const&) = delete;
  TransformationStream_TTSOutput_To_Content(TransformationStream_TTSOutput_To_Content&& obj) = default;
  TransformationStream_TTSOutput_To_Content& operator=(TransformationStream_TTSOutput_To_Content&& obj) = default;
  SwigObj_inworld_TransformationStream_TTSOutput_To_Content* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_TTSOutput_To_Content*)InputStream_Content::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content {
public:
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_delete(swig_self_);
  }
  static StatusOr_TTSOutput GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_Content const& arg2);
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content(TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content const & other);

  explicit TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content& operator=(TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content const&) = delete;
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content(TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content& operator=(TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_TTSOutput_To_AudioChunk : public InputStream_AudioChunk {
public:
  static TransformationStream_TTSOutput_To_AudioChunk null() { return TransformationStream_TTSOutput_To_AudioChunk{(SwigObj_inworld_TransformationStream_TTSOutput_To_AudioChunk*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_TTSOutput_To_AudioChunk() {
    if (swig_owns_self_) {
      inworld_TransformationStream_TTSOutput_To_AudioChunk_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_AudioChunk Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_AudioChunk Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk const & arg2, TransformationStreamThreadedFilterExecutor_TTSOutput const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_TTSOutput_To_AudioChunk(SwigObj_inworld_TransformationStream_TTSOutput_To_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : InputStream_AudioChunk{(SwigObj_inworld_InputStream_AudioChunk*)swig_self, swig_owns_self} {}
  TransformationStream_TTSOutput_To_AudioChunk(TransformationStream_TTSOutput_To_AudioChunk const&) = delete;
  TransformationStream_TTSOutput_To_AudioChunk& operator=(TransformationStream_TTSOutput_To_AudioChunk const&) = delete;
  TransformationStream_TTSOutput_To_AudioChunk(TransformationStream_TTSOutput_To_AudioChunk&& obj) = default;
  TransformationStream_TTSOutput_To_AudioChunk& operator=(TransformationStream_TTSOutput_To_AudioChunk&& obj) = default;
  SwigObj_inworld_TransformationStream_TTSOutput_To_AudioChunk* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_TTSOutput_To_AudioChunk*)InputStream_AudioChunk::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk {
public:
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_delete(swig_self_);
  }
  static StatusOr_TTSOutput GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_AudioChunk const& arg2);
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk(TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk const & other);

  explicit TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk& operator=(TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk const&) = delete;
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk(TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk& operator=(TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_TTSOutput_To_BaseData : public InputStream_BaseData {
public:
  static TransformationStream_TTSOutput_To_BaseData null() { return TransformationStream_TTSOutput_To_BaseData{(SwigObj_inworld_TransformationStream_TTSOutput_To_BaseData*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_TTSOutput_To_BaseData() {
    if (swig_owns_self_) {
      inworld_TransformationStream_TTSOutput_To_BaseData_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_BaseData Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_BaseData Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData const & arg2, TransformationStreamThreadedFilterExecutor_TTSOutput const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_TTSOutput_To_BaseData(SwigObj_inworld_TransformationStream_TTSOutput_To_BaseData* swig_self, bool swig_owns_self = true) noexcept : InputStream_BaseData{(SwigObj_inworld_InputStream_BaseData*)swig_self, swig_owns_self} {}
  TransformationStream_TTSOutput_To_BaseData(TransformationStream_TTSOutput_To_BaseData const&) = delete;
  TransformationStream_TTSOutput_To_BaseData& operator=(TransformationStream_TTSOutput_To_BaseData const&) = delete;
  TransformationStream_TTSOutput_To_BaseData(TransformationStream_TTSOutput_To_BaseData&& obj) = default;
  TransformationStream_TTSOutput_To_BaseData& operator=(TransformationStream_TTSOutput_To_BaseData&& obj) = default;
  SwigObj_inworld_TransformationStream_TTSOutput_To_BaseData* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_TTSOutput_To_BaseData*)InputStream_BaseData::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData {
public:
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_delete(swig_self_);
  }
  static StatusOr_TTSOutput GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_BaseData const& arg2);
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData(TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData const & other);

  explicit TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData& operator=(TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData const&) = delete;
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData(TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData& operator=(TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData* swig_self_;
  bool swig_owns_self_;
};

class TransformationStream_TTSOutput_To_TTSOutput : public InputStream_TTSOutput {
public:
  static TransformationStream_TTSOutput_To_TTSOutput null() { return TransformationStream_TTSOutput_To_TTSOutput{(SwigObj_inworld_TransformationStream_TTSOutput_To_TTSOutput*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TransformationStream_TTSOutput_To_TTSOutput() {
    if (swig_owns_self_) {
      inworld_TransformationStream_TTSOutput_To_TTSOutput_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_InputStream_TTSOutput Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput const & arg2, TransformationStreamDestructor const & arg3);
  static StatusOr_InputStream_TTSOutput Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput const & arg2, TransformationStreamThreadedFilterExecutor_TTSOutput const & arg3, TransformationStreamDestructor const & arg4);

  explicit TransformationStream_TTSOutput_To_TTSOutput(SwigObj_inworld_TransformationStream_TTSOutput_To_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : InputStream_TTSOutput{(SwigObj_inworld_InputStream_TTSOutput*)swig_self, swig_owns_self} {}
  TransformationStream_TTSOutput_To_TTSOutput(TransformationStream_TTSOutput_To_TTSOutput const&) = delete;
  TransformationStream_TTSOutput_To_TTSOutput& operator=(TransformationStream_TTSOutput_To_TTSOutput const&) = delete;
  TransformationStream_TTSOutput_To_TTSOutput(TransformationStream_TTSOutput_To_TTSOutput&& obj) = default;
  TransformationStream_TTSOutput_To_TTSOutput& operator=(TransformationStream_TTSOutput_To_TTSOutput&& obj) = default;
  SwigObj_inworld_TransformationStream_TTSOutput_To_TTSOutput* swig_self() const noexcept { return (SwigObj_inworld_TransformationStream_TTSOutput_To_TTSOutput*)InputStream_TTSOutput::swig_self(); }
};

class TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput {
public:
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput(void * context, void * arg2);
  ~TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_delete(swig_self_);
  }
  static StatusOr_TTSOutput GetInput(int execution_id);
  static void SetOutput(int execution_id, StatusOr_TTSOutput const& arg2);
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput(TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput const & other);

  explicit TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput(SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput& operator=(TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput const&) = delete;
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput(TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput& operator=(TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput* swig_self_;
  bool swig_owns_self_;
};

class TransformationStreamThreadedFilterExecutor_BaseData {
public:
  TransformationStreamThreadedFilterExecutor_BaseData(void * context, void * arg2);
  ~TransformationStreamThreadedFilterExecutor_BaseData() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedFilterExecutor_BaseData_delete(swig_self_);
  }
  static StatusOr_BaseData GetInput(int execution_id);
  static void SetOutput(int execution_id, bool arg2);
  TransformationStreamThreadedFilterExecutor_BaseData(TransformationStreamThreadedFilterExecutor_BaseData const & other);

  explicit TransformationStreamThreadedFilterExecutor_BaseData(SwigObj_inworld_TransformationStreamThreadedFilterExecutor_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedFilterExecutor_BaseData& operator=(TransformationStreamThreadedFilterExecutor_BaseData const&) = delete;
  TransformationStreamThreadedFilterExecutor_BaseData(TransformationStreamThreadedFilterExecutor_BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedFilterExecutor_BaseData& operator=(TransformationStreamThreadedFilterExecutor_BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedFilterExecutor_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedFilterExecutor_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedFilterExecutor_BaseData* swig_self_;
  bool swig_owns_self_;
};

class TransformationStreamThreadedFilterExecutor_string {
public:
  TransformationStreamThreadedFilterExecutor_string(void * context, void * arg2);
  ~TransformationStreamThreadedFilterExecutor_string() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedFilterExecutor_string_delete(swig_self_);
  }
  static StatusOr_string GetInput(int execution_id);
  static void SetOutput(int execution_id, bool arg2);
  TransformationStreamThreadedFilterExecutor_string(TransformationStreamThreadedFilterExecutor_string const & other);

  explicit TransformationStreamThreadedFilterExecutor_string(SwigObj_inworld_TransformationStreamThreadedFilterExecutor_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedFilterExecutor_string& operator=(TransformationStreamThreadedFilterExecutor_string const&) = delete;
  TransformationStreamThreadedFilterExecutor_string(TransformationStreamThreadedFilterExecutor_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedFilterExecutor_string& operator=(TransformationStreamThreadedFilterExecutor_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedFilterExecutor_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedFilterExecutor_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedFilterExecutor_string* swig_self_;
  bool swig_owns_self_;
};

class TransformationStreamThreadedFilterExecutor_Content {
public:
  TransformationStreamThreadedFilterExecutor_Content(void * context, void * arg2);
  ~TransformationStreamThreadedFilterExecutor_Content() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedFilterExecutor_Content_delete(swig_self_);
  }
  static StatusOr_Content GetInput(int execution_id);
  static void SetOutput(int execution_id, bool arg2);
  TransformationStreamThreadedFilterExecutor_Content(TransformationStreamThreadedFilterExecutor_Content const & other);

  explicit TransformationStreamThreadedFilterExecutor_Content(SwigObj_inworld_TransformationStreamThreadedFilterExecutor_Content* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedFilterExecutor_Content& operator=(TransformationStreamThreadedFilterExecutor_Content const&) = delete;
  TransformationStreamThreadedFilterExecutor_Content(TransformationStreamThreadedFilterExecutor_Content&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedFilterExecutor_Content& operator=(TransformationStreamThreadedFilterExecutor_Content&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedFilterExecutor_Content_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedFilterExecutor_Content* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedFilterExecutor_Content* swig_self_;
  bool swig_owns_self_;
};

class TransformationStreamThreadedFilterExecutor_AudioChunk {
public:
  TransformationStreamThreadedFilterExecutor_AudioChunk(void * context, void * arg2);
  ~TransformationStreamThreadedFilterExecutor_AudioChunk() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_delete(swig_self_);
  }
  static StatusOr_AudioChunk GetInput(int execution_id);
  static void SetOutput(int execution_id, bool arg2);
  TransformationStreamThreadedFilterExecutor_AudioChunk(TransformationStreamThreadedFilterExecutor_AudioChunk const & other);

  explicit TransformationStreamThreadedFilterExecutor_AudioChunk(SwigObj_inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedFilterExecutor_AudioChunk& operator=(TransformationStreamThreadedFilterExecutor_AudioChunk const&) = delete;
  TransformationStreamThreadedFilterExecutor_AudioChunk(TransformationStreamThreadedFilterExecutor_AudioChunk&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedFilterExecutor_AudioChunk& operator=(TransformationStreamThreadedFilterExecutor_AudioChunk&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedFilterExecutor_AudioChunk* swig_self_;
  bool swig_owns_self_;
};

class TransformationStreamThreadedFilterExecutor_TTSOutput {
public:
  TransformationStreamThreadedFilterExecutor_TTSOutput(void * context, void * arg2);
  ~TransformationStreamThreadedFilterExecutor_TTSOutput() {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_delete(swig_self_);
  }
  static StatusOr_TTSOutput GetInput(int execution_id);
  static void SetOutput(int execution_id, bool arg2);
  TransformationStreamThreadedFilterExecutor_TTSOutput(TransformationStreamThreadedFilterExecutor_TTSOutput const & other);

  explicit TransformationStreamThreadedFilterExecutor_TTSOutput(SwigObj_inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TransformationStreamThreadedFilterExecutor_TTSOutput& operator=(TransformationStreamThreadedFilterExecutor_TTSOutput const&) = delete;
  TransformationStreamThreadedFilterExecutor_TTSOutput(TransformationStreamThreadedFilterExecutor_TTSOutput&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TransformationStreamThreadedFilterExecutor_TTSOutput& operator=(TransformationStreamThreadedFilterExecutor_TTSOutput&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TransformationStreamThreadedFilterExecutor_TTSOutput* swig_self_;
  bool swig_owns_self_;
};

class AgentSpeech {
public:
  void agent_name(std::string const& agent_name);
  std::string agent_name() const;
  void utterance(std::string const& utterance);
  std::string utterance() const;
  AgentSpeech(AgentSpeech const & other);
  ~AgentSpeech() {
    if (swig_owns_self_)
      inworld_AgentSpeech_delete(swig_self_);
  }

  explicit AgentSpeech(SwigObj_inworld_AgentSpeech* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  AgentSpeech& operator=(AgentSpeech const&) = delete;
  AgentSpeech(AgentSpeech&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  AgentSpeech& operator=(AgentSpeech&& obj) noexcept {
    if (swig_owns_self_)
      inworld_AgentSpeech_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_AgentSpeech* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_AgentSpeech* swig_self_;
  bool swig_owns_self_;
};

class AgentAction {
public:
  void agent_name(std::string const& agent_name);
  std::string agent_name() const;
  void name(std::string const& name);
  std::string name() const;
  void set_parameter(std::string const& key, std::string const& arg3);
  bool contains_parameter(std::string const& key) const;
  std::string get_parameter(std::string const& key) const;
  AgentAction(AgentAction const & other);
  ~AgentAction() {
    if (swig_owns_self_)
      inworld_AgentAction_delete(swig_self_);
  }

  explicit AgentAction(SwigObj_inworld_AgentAction* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  AgentAction& operator=(AgentAction const&) = delete;
  AgentAction(AgentAction&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  AgentAction& operator=(AgentAction&& obj) noexcept {
    if (swig_owns_self_)
      inworld_AgentAction_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_AgentAction* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_AgentAction* swig_self_;
  bool swig_owns_self_;
};

class Event {
public:
  AgentSpeech * speech();
  AgentAction * action();
  bool is_valid() const;
  Event();
  Event(Event const & other);
  ~Event() {
    if (swig_owns_self_)
      inworld_Event_delete(swig_self_);
  }

  explicit Event(SwigObj_inworld_Event* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Event& operator=(Event const&) = delete;
  Event(Event&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Event& operator=(Event&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Event_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Event* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Event* swig_self_;
  bool swig_owns_self_;
};

class Intent {
public:
  void name(std::string const& name);
  std::string name() const;
  void phrases(vector_string * phrases);
  vector_string * phrases() const;
  Intent();
  Intent(Intent const & other);
  ~Intent() {
    if (swig_owns_self_)
      inworld_Intent_delete(swig_self_);
  }

  explicit Intent(SwigObj_inworld_Intent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Intent& operator=(Intent const&) = delete;
  Intent(Intent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Intent& operator=(Intent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Intent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Intent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Intent* swig_self_;
  bool swig_owns_self_;
};

class CompiledIntent {
public:
  void name(std::string const& name);
  std::string name() const;
  void normalized_phrases(vector_string * normalized_phrases);
  vector_string * normalized_phrases() const;
  void phrase_embeddings(vector_vector_float * phrase_embeddings);
  vector_vector_float * phrase_embeddings() const;
  CompiledIntent();
  CompiledIntent(CompiledIntent const & other);
  ~CompiledIntent() {
    if (swig_owns_self_)
      inworld_CompiledIntent_delete(swig_self_);
  }

  explicit CompiledIntent(SwigObj_inworld_CompiledIntent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CompiledIntent& operator=(CompiledIntent const&) = delete;
  CompiledIntent(CompiledIntent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CompiledIntent& operator=(CompiledIntent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CompiledIntent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CompiledIntent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CompiledIntent* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_Language {
public:
  StatusOr_Language();
  StatusOr_Language(Language const & value);
  StatusOr_Language(Status const & status);
  bool ok() const;
  Status status() const;
  Language value() const;
  StatusOr_Language(StatusOr_Language const & other);
  ~StatusOr_Language() {
    if (swig_owns_self_)
      inworld_StatusOr_Language_delete(swig_self_);
  }

  explicit StatusOr_Language(SwigObj_inworld_StatusOr_Language* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_Language& operator=(StatusOr_Language const&) = delete;
  StatusOr_Language(StatusOr_Language&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_Language& operator=(StatusOr_Language&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_Language_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_Language* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_Language* swig_self_;
  bool swig_owns_self_;
};

class Language {
public:
  void lang(std::string const& lang);
  std::string lang() const;
  void locale(optional_string * locale);
  optional_string * locale() const;
  static StatusOr_Language FromString(std::string const& language_code);
  std::string ToString() const;
  static Language English();
  static Language Chinese();
  static Language Korean();
  static Language Japanese();
  static Language Russian();
  static Language Spanish();
  static Language French();
  static Language German();
  static Language Italian();
  static Language Portuguese();
  static Language Arabic();
  static Language Hindi();
  static Language Dutch();
  static Language Swedish();
  static Language Norwegian();
  static Language Danish();
  static Language Finnish();
  static Language Polish();
  static Language Turkish();
  static Language Thai();
  static Language Vietnamese();
  static Language Indonesian();
  static Language Malay();
  static Language Hebrew();
  static Language Ukrainian();
  Language();
  Language(Language const & other);
  ~Language() {
    if (swig_owns_self_)
      inworld_Language_delete(swig_self_);
  }

  explicit Language(SwigObj_inworld_Language* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Language& operator=(Language const&) = delete;
  Language(Language&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Language& operator=(Language&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Language_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Language* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Language* swig_self_;
  bool swig_owns_self_;
};

class DeviceInfo {
public:
  std::string name() const;
  unsigned long long free_memory_bytes() const;
  unsigned long long total_memory_bytes() const;
  DeviceInfo();
  DeviceInfo(DeviceInfo const & other);
  ~DeviceInfo() {
    if (swig_owns_self_)
      inworld_DeviceInfo_delete(swig_self_);
  }

  explicit DeviceInfo(SwigObj_inworld_DeviceInfo* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  DeviceInfo& operator=(DeviceInfo const&) = delete;
  DeviceInfo(DeviceInfo&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  DeviceInfo& operator=(DeviceInfo&& obj) noexcept {
    if (swig_owns_self_)
      inworld_DeviceInfo_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_DeviceInfo* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_DeviceInfo* swig_self_;
  bool swig_owns_self_;
};

class Device {
public:
  DeviceType type() const;
  signed char index() const;
  DeviceInfo info() const;
  ~Device() {
    if (swig_owns_self_)
      inworld_Device_delete(swig_self_);
  }

  explicit Device(SwigObj_inworld_Device* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Device(Device const&) = delete;
  Device& operator=(Device const&) = delete;
  Device(Device&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Device& operator=(Device&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Device_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Device* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Device* swig_self_;
  bool swig_owns_self_;
};

class DeviceRegistry {
public:
  virtual ~DeviceRegistry() {
    if (swig_owns_self_)
      inworld_DeviceRegistry_delete(swig_self_);
  }
  static DeviceRegistry GetInstance();
  vector_Device GetAvailableDevices() const;

  explicit DeviceRegistry(SwigObj_inworld_DeviceRegistry* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  DeviceRegistry(DeviceRegistry const&) = delete;
  DeviceRegistry& operator=(DeviceRegistry const&) = delete;
  DeviceRegistry(DeviceRegistry&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  DeviceRegistry& operator=(DeviceRegistry&& obj) noexcept {
    if (swig_owns_self_)
      inworld_DeviceRegistry_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_DeviceRegistry* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_DeviceRegistry* swig_self_;
  bool swig_owns_self_;
};

class ModelProperties {
public:
  void model_id(std::string const& model_id);
  std::string model_id() const;
  ModelProperties();
  ModelProperties(ModelProperties const & other);
  ~ModelProperties() {
    if (swig_owns_self_)
      inworld_ModelProperties_delete(swig_self_);
  }

  explicit ModelProperties(SwigObj_inworld_ModelProperties* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ModelProperties& operator=(ModelProperties const&) = delete;
  ModelProperties(ModelProperties&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ModelProperties& operator=(ModelProperties&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ModelProperties_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ModelProperties* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ModelProperties* swig_self_;
  bool swig_owns_self_;
};

class ModelInterface {
public:
  static ModelInterface null() { return ModelInterface{(SwigObj_inworld_ModelInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~ModelInterface() {
    if (swig_owns_self_)
      inworld_ModelInterface_delete(swig_self_);
  }
  virtual ModelProperties model_properties() const;
  bool is_valid() const;

  explicit ModelInterface(SwigObj_inworld_ModelInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ModelInterface(ModelInterface const&) = delete;
  ModelInterface& operator=(ModelInterface const&) = delete;
  ModelInterface(ModelInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ModelInterface& operator=(ModelInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ModelInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ModelInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ModelInterface* swig_self_;
  bool swig_owns_self_;
};

class TextEmbedderInterface : public ModelInterface {
public:
  static TextEmbedderInterface null() { return TextEmbedderInterface{(SwigObj_inworld_TextEmbedderInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~TextEmbedderInterface() {
    if (swig_owns_self_) {
      inworld_TextEmbedderInterface_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  virtual StatusOr_vector_float Embed(std::string const& text) const;
  virtual StatusOr_vector_vector_float EmbedBatch(vector_string const & texts) const;
  bool is_valid() const;

  explicit TextEmbedderInterface(SwigObj_inworld_TextEmbedderInterface* swig_self, bool swig_owns_self = true) noexcept : ModelInterface{(SwigObj_inworld_ModelInterface*)swig_self, swig_owns_self} {}
  TextEmbedderInterface(TextEmbedderInterface const&) = delete;
  TextEmbedderInterface& operator=(TextEmbedderInterface const&) = delete;
  TextEmbedderInterface(TextEmbedderInterface&& obj) = default;
  TextEmbedderInterface& operator=(TextEmbedderInterface&& obj) = default;
  SwigObj_inworld_TextEmbedderInterface* swig_self() const noexcept { return (SwigObj_inworld_TextEmbedderInterface*)ModelInterface::swig_self(); }
};

class optional_LocalTextEmbedderConfig {
public:
  optional_LocalTextEmbedderConfig();
  optional_LocalTextEmbedderConfig(LocalTextEmbedderConfig const & value);
  optional_LocalTextEmbedderConfig(optional_LocalTextEmbedderConfig const & other);
  ~optional_LocalTextEmbedderConfig() {
    if (swig_owns_self_)
      inworld_optional_LocalTextEmbedderConfig_delete(swig_self_);
  }
  bool has_value() const;
  LocalTextEmbedderConfig value();
  LocalTextEmbedderConfig value() const;
  LocalTextEmbedderConfig value_or(LocalTextEmbedderConfig const & default_value) const;
  void reset();
  LocalTextEmbedderConfig operator *();
  LocalTextEmbedderConfig operator *() const;
  LocalTextEmbedderConfig get_value();
  void set_value(LocalTextEmbedderConfig & t);

  explicit optional_LocalTextEmbedderConfig(SwigObj_inworld_optional_LocalTextEmbedderConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_LocalTextEmbedderConfig& operator=(optional_LocalTextEmbedderConfig const&) = delete;
  optional_LocalTextEmbedderConfig(optional_LocalTextEmbedderConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_LocalTextEmbedderConfig& operator=(optional_LocalTextEmbedderConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_LocalTextEmbedderConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_LocalTextEmbedderConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_LocalTextEmbedderConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_RemoteTextEmbedderConfig {
public:
  optional_RemoteTextEmbedderConfig();
  optional_RemoteTextEmbedderConfig(RemoteTextEmbedderConfig const & value);
  optional_RemoteTextEmbedderConfig(optional_RemoteTextEmbedderConfig const & other);
  ~optional_RemoteTextEmbedderConfig() {
    if (swig_owns_self_)
      inworld_optional_RemoteTextEmbedderConfig_delete(swig_self_);
  }
  bool has_value() const;
  RemoteTextEmbedderConfig value();
  RemoteTextEmbedderConfig value() const;
  RemoteTextEmbedderConfig value_or(RemoteTextEmbedderConfig const & default_value) const;
  void reset();
  RemoteTextEmbedderConfig operator *();
  RemoteTextEmbedderConfig operator *() const;
  RemoteTextEmbedderConfig get_value();
  void set_value(RemoteTextEmbedderConfig & t);

  explicit optional_RemoteTextEmbedderConfig(SwigObj_inworld_optional_RemoteTextEmbedderConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_RemoteTextEmbedderConfig& operator=(optional_RemoteTextEmbedderConfig const&) = delete;
  optional_RemoteTextEmbedderConfig(optional_RemoteTextEmbedderConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_RemoteTextEmbedderConfig& operator=(optional_RemoteTextEmbedderConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_RemoteTextEmbedderConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_RemoteTextEmbedderConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_RemoteTextEmbedderConfig* swig_self_;
  bool swig_owns_self_;
};

class LocalTextEmbedderConfig {
public:
  void model_path(std::string const& model_path);
  std::string model_path() const;
  void device(Device * device);
  Device * device() const;
  LocalTextEmbedderConfig();
  LocalTextEmbedderConfig(LocalTextEmbedderConfig const & other);
  ~LocalTextEmbedderConfig() {
    if (swig_owns_self_)
      inworld_LocalTextEmbedderConfig_delete(swig_self_);
  }

  explicit LocalTextEmbedderConfig(SwigObj_inworld_LocalTextEmbedderConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LocalTextEmbedderConfig& operator=(LocalTextEmbedderConfig const&) = delete;
  LocalTextEmbedderConfig(LocalTextEmbedderConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LocalTextEmbedderConfig& operator=(LocalTextEmbedderConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LocalTextEmbedderConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LocalTextEmbedderConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LocalTextEmbedderConfig* swig_self_;
  bool swig_owns_self_;
};

class RemoteTextEmbedderConfig {
public:
  void provider(std::string const& provider);
  std::string provider() const;
  void model_name(std::string const& model_name);
  std::string model_name() const;
  void api_key(std::string const& api_key);
  std::string api_key() const;
  RemoteTextEmbedderConfig();
  RemoteTextEmbedderConfig(RemoteTextEmbedderConfig const & other);
  ~RemoteTextEmbedderConfig() {
    if (swig_owns_self_)
      inworld_RemoteTextEmbedderConfig_delete(swig_self_);
  }

  explicit RemoteTextEmbedderConfig(SwigObj_inworld_RemoteTextEmbedderConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  RemoteTextEmbedderConfig& operator=(RemoteTextEmbedderConfig const&) = delete;
  RemoteTextEmbedderConfig(RemoteTextEmbedderConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  RemoteTextEmbedderConfig& operator=(RemoteTextEmbedderConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_RemoteTextEmbedderConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_RemoteTextEmbedderConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_RemoteTextEmbedderConfig* swig_self_;
  bool swig_owns_self_;
};

class TextEmbedderCreationConfig {
public:
  bool has_local_config() const;
  bool has_remote_config() const;
  optional_LocalTextEmbedderConfig get_local_config() const;
  optional_RemoteTextEmbedderConfig get_remote_config() const;
  void set_local_config(LocalTextEmbedderConfig const & config);
  void set_remote_config(RemoteTextEmbedderConfig const & config);
  TextEmbedderCreationConfig();
  TextEmbedderCreationConfig(TextEmbedderCreationConfig const & other);
  ~TextEmbedderCreationConfig() {
    if (swig_owns_self_)
      inworld_TextEmbedderCreationConfig_delete(swig_self_);
  }

  explicit TextEmbedderCreationConfig(SwigObj_inworld_TextEmbedderCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextEmbedderCreationConfig& operator=(TextEmbedderCreationConfig const&) = delete;
  TextEmbedderCreationConfig(TextEmbedderCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextEmbedderCreationConfig& operator=(TextEmbedderCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextEmbedderCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextEmbedderCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextEmbedderCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class TextEmbedderFactory {
public:
  virtual ~TextEmbedderFactory() {
    if (swig_owns_self_)
      inworld_TextEmbedderFactory_delete(swig_self_);
  }
  StatusOr_TextEmbedderInterface CreateTextEmbedder(TextEmbedderCreationConfig const & config) const;
  TextEmbedderFactory();
  TextEmbedderFactory(TextEmbedderFactory const & other);

  explicit TextEmbedderFactory(SwigObj_inworld_TextEmbedderFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextEmbedderFactory& operator=(TextEmbedderFactory const&) = delete;
  TextEmbedderFactory(TextEmbedderFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextEmbedderFactory& operator=(TextEmbedderFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextEmbedderFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextEmbedderFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextEmbedderFactory* swig_self_;
  bool swig_owns_self_;
};

class optional_float {
public:
  optional_float();
  optional_float(float value);
  optional_float(optional_float const & other);
  ~optional_float() {
    if (swig_owns_self_)
      inworld_optional_float_delete(swig_self_);
  }
  bool has_value() const;
  float * value();
  float value() const;
  float value_or(float default_value) const;
  void reset();
  float * operator *();
  float operator *() const;
  float * get_value();
  void set_value(float * t);

  explicit optional_float(SwigObj_inworld_optional_float* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_float& operator=(optional_float const&) = delete;
  optional_float(optional_float&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_float& operator=(optional_float&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_float_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_float* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_float* swig_self_;
  bool swig_owns_self_;
};

class optional_int {
public:
  optional_int();
  optional_int(int value);
  optional_int(optional_int const & other);
  ~optional_int() {
    if (swig_owns_self_)
      inworld_optional_int_delete(swig_self_);
  }
  bool has_value() const;
  int * value();
  int value() const;
  int value_or(int default_value) const;
  void reset();
  int * operator *();
  int operator *() const;
  int * get_value();
  void set_value(int * t);

  explicit optional_int(SwigObj_inworld_optional_int* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_int& operator=(optional_int const&) = delete;
  optional_int(optional_int&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_int& operator=(optional_int&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_int_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_int* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_int* swig_self_;
  bool swig_owns_self_;
};

class optional_sizet {
public:
  optional_sizet();
  optional_sizet(size_t value);
  optional_sizet(optional_sizet const & other);
  ~optional_sizet() {
    if (swig_owns_self_)
      inworld_optional_sizet_delete(swig_self_);
  }
  bool has_value() const;
  size_t * value();
  size_t value() const;
  size_t value_or(size_t default_value) const;
  void reset();
  size_t * operator *();
  size_t operator *() const;
  size_t * get_value();
  void set_value(size_t * t);

  explicit optional_sizet(SwigObj_inworld_optional_sizet* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_sizet& operator=(optional_sizet const&) = delete;
  optional_sizet(optional_sizet&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_sizet& operator=(optional_sizet&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_sizet_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_sizet* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_sizet* swig_self_;
  bool swig_owns_self_;
};

class optional_string {
public:
  optional_string();
  optional_string(std::string const& value);
  optional_string(optional_string const & other);
  ~optional_string() {
    if (swig_owns_self_)
      inworld_optional_string_delete(swig_self_);
  }
  bool has_value() const;
  char * value();
  std::string value() const;
  std::string value_or(std::string const& default_value) const;
  void reset();
  char * operator *();
  std::string operator *() const;
  char * get_value();
  void set_value(char * t);

  explicit optional_string(SwigObj_inworld_optional_string* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_string& operator=(optional_string const&) = delete;
  optional_string(optional_string&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_string& operator=(optional_string&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_string_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_string* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_string* swig_self_;
  bool swig_owns_self_;
};

class optional_UserContext {
public:
  optional_UserContext();
  optional_UserContext(UserContext const & value);
  optional_UserContext(optional_UserContext const & other);
  ~optional_UserContext() {
    if (swig_owns_self_)
      inworld_optional_UserContext_delete(swig_self_);
  }
  bool has_value() const;
  UserContext value();
  UserContext value() const;
  UserContext value_or(UserContext const & default_value) const;
  void reset();
  UserContext operator *();
  UserContext operator *() const;
  UserContext get_value();
  void set_value(UserContext & t);

  explicit optional_UserContext(SwigObj_inworld_optional_UserContext* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_UserContext& operator=(optional_UserContext const&) = delete;
  optional_UserContext(optional_UserContext&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_UserContext& operator=(optional_UserContext&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_UserContext_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_UserContext* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_UserContext* swig_self_;
  bool swig_owns_self_;
};

class AudioChunk {
public:
  void data(vector_float * data);
  vector_float * data() const;
  void sample_rate(int sample_rate);
  int sample_rate() const;
  AudioChunk();
  AudioChunk(AudioChunk const & other);
  ~AudioChunk() {
    if (swig_owns_self_)
      inworld_AudioChunk_delete(swig_self_);
  }

  explicit AudioChunk(SwigObj_inworld_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  AudioChunk& operator=(AudioChunk const&) = delete;
  AudioChunk(AudioChunk&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  AudioChunk& operator=(AudioChunk&& obj) noexcept {
    if (swig_owns_self_)
      inworld_AudioChunk_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_AudioChunk* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_AudioChunk* swig_self_;
  bool swig_owns_self_;
};

class Duration {
public:
  Duration();
  Duration(Duration const & other);
  ~Duration() {
    if (swig_owns_self_)
      inworld_Duration_delete(swig_self_);
  }

  explicit Duration(SwigObj_inworld_Duration* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Duration& operator=(Duration const&) = delete;
  Duration(Duration&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Duration& operator=(Duration&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Duration_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Duration* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Duration* swig_self_;
  bool swig_owns_self_;
};

class SpeechSynthesisPostprocessingConfig {
public:
  void sample_rate(int sample_rate);
  int sample_rate() const;
  SpeechSynthesisPostprocessingConfig();
  SpeechSynthesisPostprocessingConfig(SpeechSynthesisPostprocessingConfig const & other);
  ~SpeechSynthesisPostprocessingConfig() {
    if (swig_owns_self_)
      inworld_SpeechSynthesisPostprocessingConfig_delete(swig_self_);
  }

  explicit SpeechSynthesisPostprocessingConfig(SwigObj_inworld_SpeechSynthesisPostprocessingConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SpeechSynthesisPostprocessingConfig& operator=(SpeechSynthesisPostprocessingConfig const&) = delete;
  SpeechSynthesisPostprocessingConfig(SpeechSynthesisPostprocessingConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SpeechSynthesisPostprocessingConfig& operator=(SpeechSynthesisPostprocessingConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SpeechSynthesisPostprocessingConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SpeechSynthesisPostprocessingConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SpeechSynthesisPostprocessingConfig* swig_self_;
  bool swig_owns_self_;
};

class SpeechSynthesisInferenceConfig {
public:
  void temperature(float temperature);
  float temperature() const;
  void speaking_rate(float speaking_rate);
  float speaking_rate() const;
  SpeechSynthesisInferenceConfig();
  SpeechSynthesisInferenceConfig(SpeechSynthesisInferenceConfig const & other);
  ~SpeechSynthesisInferenceConfig() {
    if (swig_owns_self_)
      inworld_SpeechSynthesisInferenceConfig_delete(swig_self_);
  }

  explicit SpeechSynthesisInferenceConfig(SwigObj_inworld_SpeechSynthesisInferenceConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SpeechSynthesisInferenceConfig& operator=(SpeechSynthesisInferenceConfig const&) = delete;
  SpeechSynthesisInferenceConfig(SpeechSynthesisInferenceConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SpeechSynthesisInferenceConfig& operator=(SpeechSynthesisInferenceConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SpeechSynthesisInferenceConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SpeechSynthesisInferenceConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SpeechSynthesisInferenceConfig* swig_self_;
  bool swig_owns_self_;
};

class InworldSpeechSynthesisConfig {
public:
  void model_id(std::string const& model_id);
  std::string model_id() const;
  void postprocessing(SpeechSynthesisPostprocessingConfig * postprocessing);
  SpeechSynthesisPostprocessingConfig * postprocessing() const;
  void inference(SpeechSynthesisInferenceConfig * inference);
  SpeechSynthesisInferenceConfig * inference() const;
  InworldSpeechSynthesisConfig();
  InworldSpeechSynthesisConfig(InworldSpeechSynthesisConfig const & other);
  ~InworldSpeechSynthesisConfig() {
    if (swig_owns_self_)
      inworld_InworldSpeechSynthesisConfig_delete(swig_self_);
  }

  explicit InworldSpeechSynthesisConfig(SwigObj_inworld_InworldSpeechSynthesisConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  InworldSpeechSynthesisConfig& operator=(InworldSpeechSynthesisConfig const&) = delete;
  InworldSpeechSynthesisConfig(InworldSpeechSynthesisConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  InworldSpeechSynthesisConfig& operator=(InworldSpeechSynthesisConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_InworldSpeechSynthesisConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_InworldSpeechSynthesisConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_InworldSpeechSynthesisConfig* swig_self_;
  bool swig_owns_self_;
};

class ElevenLabsSpeechSynthesisConfig {
public:
  void query_params(QueryParams * query_params);
  QueryParams * query_params() const;
  void request_params(RequestParams * request_params);
  RequestParams * request_params() const;
  ElevenLabsSpeechSynthesisConfig();
  ElevenLabsSpeechSynthesisConfig(ElevenLabsSpeechSynthesisConfig const & other);
  ~ElevenLabsSpeechSynthesisConfig() {
    if (swig_owns_self_)
      inworld_ElevenLabsSpeechSynthesisConfig_delete(swig_self_);
  }

  explicit ElevenLabsSpeechSynthesisConfig(SwigObj_inworld_ElevenLabsSpeechSynthesisConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ElevenLabsSpeechSynthesisConfig& operator=(ElevenLabsSpeechSynthesisConfig const&) = delete;
  ElevenLabsSpeechSynthesisConfig(ElevenLabsSpeechSynthesisConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ElevenLabsSpeechSynthesisConfig& operator=(ElevenLabsSpeechSynthesisConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ElevenLabsSpeechSynthesisConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ElevenLabsSpeechSynthesisConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ElevenLabsSpeechSynthesisConfig* swig_self_;
  bool swig_owns_self_;
};

class QueryParams {
public:
  enum class OutputFormat  {
    MP3_22050_32,
    MP3_44100_32,
    MP3_44100_64,
    MP3_44100_96,
    MP3_44100_128,
    MP3_44100_192
  };

  void enable_logging(bool enable_logging);
  bool enable_logging() const;
  void output_format(QueryParams::OutputFormat output_format);
  QueryParams::OutputFormat output_format() const;
  QueryParams();
  QueryParams(QueryParams const & other);
  ~QueryParams() {
    if (swig_owns_self_)
      inworld_QueryParams_delete(swig_self_);
  }

  explicit QueryParams(SwigObj_inworld_QueryParams* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  QueryParams& operator=(QueryParams const&) = delete;
  QueryParams(QueryParams&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  QueryParams& operator=(QueryParams&& obj) noexcept {
    if (swig_owns_self_)
      inworld_QueryParams_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_QueryParams* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_QueryParams* swig_self_;
  bool swig_owns_self_;
};

class RequestParams {
public:
  enum class TextNormalization  {
    AUTO,
    ON,
    OFF
  };

  void model_id(std::string const& model_id);
  std::string model_id() const;
  void apply_text_normalization(RequestParams::TextNormalization apply_text_normalization);
  RequestParams::TextNormalization apply_text_normalization() const;
  RequestParams();
  RequestParams(RequestParams const & other);
  ~RequestParams() {
    if (swig_owns_self_)
      inworld_RequestParams_delete(swig_self_);
  }

  explicit RequestParams(SwigObj_inworld_RequestParams* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  RequestParams& operator=(RequestParams const&) = delete;
  RequestParams(RequestParams&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  RequestParams& operator=(RequestParams&& obj) noexcept {
    if (swig_owns_self_)
      inworld_RequestParams_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_RequestParams* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_RequestParams* swig_self_;
  bool swig_owns_self_;
};

class SpeechSynthesisConfig {
public:
  InworldSpeechSynthesisConfig * inworld_config();
  ElevenLabsSpeechSynthesisConfig * eleven_labs_config();
  SpeechSynthesisConfig();
  SpeechSynthesisConfig(SpeechSynthesisConfig const & other);
  ~SpeechSynthesisConfig() {
    if (swig_owns_self_)
      inworld_SpeechSynthesisConfig_delete(swig_self_);
  }

  explicit SpeechSynthesisConfig(SwigObj_inworld_SpeechSynthesisConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SpeechSynthesisConfig& operator=(SpeechSynthesisConfig const&) = delete;
  SpeechSynthesisConfig(SpeechSynthesisConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SpeechSynthesisConfig& operator=(SpeechSynthesisConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SpeechSynthesisConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SpeechSynthesisConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SpeechSynthesisConfig* swig_self_;
  bool swig_owns_self_;
};

class Voice {
public:
  void id(std::string const& id);
  std::string id() const;
  void language(optional_Language * language);
  optional_Language * language() const;
  Voice();
  Voice(Voice const & other);
  ~Voice() {
    if (swig_owns_self_)
      inworld_Voice_delete(swig_self_);
  }

  explicit Voice(SwigObj_inworld_Voice* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Voice& operator=(Voice const&) = delete;
  Voice(Voice&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Voice& operator=(Voice&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Voice_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Voice* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Voice* swig_self_;
  bool swig_owns_self_;
};

class TTSInterface : public ModelInterface {
public:
  static TTSInterface null() { return TTSInterface{(SwigObj_inworld_TTSInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~TTSInterface() {
    if (swig_owns_self_) {
      inworld_TTSInterface_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;
  StatusOr_InputStream_AudioChunk SynthesizeSpeech(Voice const & voice, std::string const& arg3) const;
  StatusOr_InputStream_AudioChunk SynthesizeSpeech(Voice const & voice, std::string const& arg3, SpeechSynthesisConfig const & arg4) const;

  explicit TTSInterface(SwigObj_inworld_TTSInterface* swig_self, bool swig_owns_self = true) noexcept : ModelInterface{(SwigObj_inworld_ModelInterface*)swig_self, swig_owns_self} {}
  TTSInterface(TTSInterface const&) = delete;
  TTSInterface& operator=(TTSInterface const&) = delete;
  TTSInterface(TTSInterface&& obj) = default;
  TTSInterface& operator=(TTSInterface&& obj) = default;
  SwigObj_inworld_TTSInterface* swig_self() const noexcept { return (SwigObj_inworld_TTSInterface*)ModelInterface::swig_self(); }
};

class optional_Voice {
public:
  optional_Voice();
  optional_Voice(Voice const & value);
  optional_Voice(optional_Voice const & other);
  ~optional_Voice() {
    if (swig_owns_self_)
      inworld_optional_Voice_delete(swig_self_);
  }
  bool has_value() const;
  Voice value();
  Voice value() const;
  Voice value_or(Voice const & default_value) const;
  void reset();
  Voice operator *();
  Voice operator *() const;
  Voice get_value();
  void set_value(Voice & t);

  explicit optional_Voice(SwigObj_inworld_optional_Voice* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_Voice& operator=(optional_Voice const&) = delete;
  optional_Voice(optional_Voice&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_Voice& operator=(optional_Voice&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_Voice_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_Voice* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_Voice* swig_self_;
  bool swig_owns_self_;
};

class optional_TextGenerationConfig {
public:
  optional_TextGenerationConfig();
  optional_TextGenerationConfig(TextGenerationConfig const & value);
  optional_TextGenerationConfig(optional_TextGenerationConfig const & other);
  ~optional_TextGenerationConfig() {
    if (swig_owns_self_)
      inworld_optional_TextGenerationConfig_delete(swig_self_);
  }
  bool has_value() const;
  TextGenerationConfig value();
  TextGenerationConfig value() const;
  TextGenerationConfig value_or(TextGenerationConfig const & default_value) const;
  void reset();
  TextGenerationConfig operator *();
  TextGenerationConfig operator *() const;
  TextGenerationConfig get_value();
  void set_value(TextGenerationConfig & t);

  explicit optional_TextGenerationConfig(SwigObj_inworld_optional_TextGenerationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_TextGenerationConfig& operator=(optional_TextGenerationConfig const&) = delete;
  optional_TextGenerationConfig(optional_TextGenerationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_TextGenerationConfig& operator=(optional_TextGenerationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_TextGenerationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_TextGenerationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_TextGenerationConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_ToolChoice {
public:
  optional_ToolChoice();
  optional_ToolChoice(ToolChoice const & value);
  optional_ToolChoice(optional_ToolChoice const & other);
  ~optional_ToolChoice() {
    if (swig_owns_self_)
      inworld_optional_ToolChoice_delete(swig_self_);
  }
  bool has_value() const;
  ToolChoice value();
  ToolChoice value() const;
  ToolChoice value_or(ToolChoice const & default_value) const;
  void reset();
  ToolChoice operator *();
  ToolChoice operator *() const;
  ToolChoice get_value();
  void set_value(ToolChoice & t);

  explicit optional_ToolChoice(SwigObj_inworld_optional_ToolChoice* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_ToolChoice& operator=(optional_ToolChoice const&) = delete;
  optional_ToolChoice(optional_ToolChoice&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_ToolChoice& operator=(optional_ToolChoice&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_ToolChoice_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_ToolChoice* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_ToolChoice* swig_self_;
  bool swig_owns_self_;
};

class Vector_ChatMessage {
public:
  Vector_ChatMessage();
  Vector_ChatMessage(Vector_ChatMessage const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(ChatMessage const & x);
  ChatMessage get(int i);
  void set(int i, ChatMessage const & arg3);
  ~Vector_ChatMessage() {
    if (swig_owns_self_)
      inworld_Vector_ChatMessage_delete(swig_self_);
  }

  explicit Vector_ChatMessage(SwigObj_inworld_Vector_ChatMessage* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Vector_ChatMessage& operator=(Vector_ChatMessage const&) = delete;
  Vector_ChatMessage(Vector_ChatMessage&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Vector_ChatMessage& operator=(Vector_ChatMessage&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Vector_ChatMessage_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Vector_ChatMessage* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Vector_ChatMessage* swig_self_;
  bool swig_owns_self_;
};

class Vector_Tool {
public:
  Vector_Tool();
  Vector_Tool(Vector_Tool const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Tool const & x);
  Tool get(int i);
  void set(int i, Tool const & arg3);
  ~Vector_Tool() {
    if (swig_owns_self_)
      inworld_Vector_Tool_delete(swig_self_);
  }

  explicit Vector_Tool(SwigObj_inworld_Vector_Tool* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Vector_Tool& operator=(Vector_Tool const&) = delete;
  Vector_Tool(Vector_Tool&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Vector_Tool& operator=(Vector_Tool&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Vector_Tool_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Vector_Tool* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Vector_Tool* swig_self_;
  bool swig_owns_self_;
};

class optional_vector_ChatMessage {
public:
  optional_vector_ChatMessage();
  optional_vector_ChatMessage(Vector_ChatMessage const & value);
  optional_vector_ChatMessage(optional_vector_ChatMessage const & other);
  ~optional_vector_ChatMessage() {
    if (swig_owns_self_)
      inworld_optional_vector_ChatMessage_delete(swig_self_);
  }
  bool has_value() const;
  Vector_ChatMessage value();
  Vector_ChatMessage value() const;
  Vector_ChatMessage value_or(Vector_ChatMessage const & default_value) const;
  void reset();
  Vector_ChatMessage operator *();
  Vector_ChatMessage operator *() const;
  Vector_ChatMessage get_value();
  void set_value(Vector_ChatMessage & t);

  explicit optional_vector_ChatMessage(SwigObj_inworld_optional_vector_ChatMessage* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_vector_ChatMessage& operator=(optional_vector_ChatMessage const&) = delete;
  optional_vector_ChatMessage(optional_vector_ChatMessage&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_vector_ChatMessage& operator=(optional_vector_ChatMessage&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_vector_ChatMessage_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_vector_ChatMessage* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_vector_ChatMessage* swig_self_;
  bool swig_owns_self_;
};

class optional_vector_Tool {
public:
  optional_vector_Tool();
  optional_vector_Tool(Vector_Tool const & value);
  optional_vector_Tool(optional_vector_Tool const & other);
  ~optional_vector_Tool() {
    if (swig_owns_self_)
      inworld_optional_vector_Tool_delete(swig_self_);
  }
  bool has_value() const;
  Vector_Tool value();
  Vector_Tool value() const;
  Vector_Tool value_or(Vector_Tool const & default_value) const;
  void reset();
  Vector_Tool operator *();
  Vector_Tool operator *() const;
  Vector_Tool get_value();
  void set_value(Vector_Tool & t);

  explicit optional_vector_Tool(SwigObj_inworld_optional_vector_Tool* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_vector_Tool& operator=(optional_vector_Tool const&) = delete;
  optional_vector_Tool(optional_vector_Tool&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_vector_Tool& operator=(optional_vector_Tool&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_vector_Tool_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_vector_Tool* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_vector_Tool* swig_self_;
  bool swig_owns_self_;
};

class SpeechRecognitionConfig {
public:
  void language(optional_Language * language);
  optional_Language * language() const;
  SpeechRecognitionConfig();
  SpeechRecognitionConfig(SpeechRecognitionConfig const & other);
  ~SpeechRecognitionConfig() {
    if (swig_owns_self_)
      inworld_SpeechRecognitionConfig_delete(swig_self_);
  }

  explicit SpeechRecognitionConfig(SwigObj_inworld_SpeechRecognitionConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SpeechRecognitionConfig& operator=(SpeechRecognitionConfig const&) = delete;
  SpeechRecognitionConfig(SpeechRecognitionConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SpeechRecognitionConfig& operator=(SpeechRecognitionConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SpeechRecognitionConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SpeechRecognitionConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SpeechRecognitionConfig* swig_self_;
  bool swig_owns_self_;
};

class STTInterface : public ModelInterface {
public:
  static STTInterface null() { return STTInterface{(SwigObj_inworld_STTInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~STTInterface() {
    if (swig_owns_self_) {
      inworld_STTInterface_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;
  StatusOr_InputStream_string RecognizeSpeech(AudioChunk & audio_chunk, SpeechRecognitionConfig const & arg3) const;

  explicit STTInterface(SwigObj_inworld_STTInterface* swig_self, bool swig_owns_self = true) noexcept : ModelInterface{(SwigObj_inworld_ModelInterface*)swig_self, swig_owns_self} {}
  STTInterface(STTInterface const&) = delete;
  STTInterface& operator=(STTInterface const&) = delete;
  STTInterface(STTInterface&& obj) = default;
  STTInterface& operator=(STTInterface&& obj) = default;
  SwigObj_inworld_STTInterface* swig_self() const noexcept { return (SwigObj_inworld_STTInterface*)ModelInterface::swig_self(); }
};

class optional_SpeechSynthesisConfig {
public:
  optional_SpeechSynthesisConfig();
  optional_SpeechSynthesisConfig(SpeechSynthesisConfig const & value);
  optional_SpeechSynthesisConfig(optional_SpeechSynthesisConfig const & other);
  ~optional_SpeechSynthesisConfig() {
    if (swig_owns_self_)
      inworld_optional_SpeechSynthesisConfig_delete(swig_self_);
  }
  bool has_value() const;
  SpeechSynthesisConfig value();
  SpeechSynthesisConfig value() const;
  SpeechSynthesisConfig value_or(SpeechSynthesisConfig const & default_value) const;
  void reset();
  SpeechSynthesisConfig operator *();
  SpeechSynthesisConfig operator *() const;
  SpeechSynthesisConfig get_value();
  void set_value(SpeechSynthesisConfig & t);

  explicit optional_SpeechSynthesisConfig(SwigObj_inworld_optional_SpeechSynthesisConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_SpeechSynthesisConfig& operator=(optional_SpeechSynthesisConfig const&) = delete;
  optional_SpeechSynthesisConfig(optional_SpeechSynthesisConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_SpeechSynthesisConfig& operator=(optional_SpeechSynthesisConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_SpeechSynthesisConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_SpeechSynthesisConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_SpeechSynthesisConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_SpeechRecognitionConfig {
public:
  optional_SpeechRecognitionConfig();
  optional_SpeechRecognitionConfig(SpeechRecognitionConfig const & value);
  optional_SpeechRecognitionConfig(optional_SpeechRecognitionConfig const & other);
  ~optional_SpeechRecognitionConfig() {
    if (swig_owns_self_)
      inworld_optional_SpeechRecognitionConfig_delete(swig_self_);
  }
  bool has_value() const;
  SpeechRecognitionConfig value();
  SpeechRecognitionConfig value() const;
  SpeechRecognitionConfig value_or(SpeechRecognitionConfig const & default_value) const;
  void reset();
  SpeechRecognitionConfig operator *();
  SpeechRecognitionConfig operator *() const;
  SpeechRecognitionConfig get_value();
  void set_value(SpeechRecognitionConfig & t);

  explicit optional_SpeechRecognitionConfig(SwigObj_inworld_optional_SpeechRecognitionConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_SpeechRecognitionConfig& operator=(optional_SpeechRecognitionConfig const&) = delete;
  optional_SpeechRecognitionConfig(optional_SpeechRecognitionConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_SpeechRecognitionConfig& operator=(optional_SpeechRecognitionConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_SpeechRecognitionConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_SpeechRecognitionConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_SpeechRecognitionConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_TextClassifierConfig {
public:
  optional_TextClassifierConfig();
  optional_TextClassifierConfig(TextClassifierConfig const & value);
  optional_TextClassifierConfig(optional_TextClassifierConfig const & other);
  ~optional_TextClassifierConfig() {
    if (swig_owns_self_)
      inworld_optional_TextClassifierConfig_delete(swig_self_);
  }
  bool has_value() const;
  TextClassifierConfig value();
  TextClassifierConfig value() const;
  TextClassifierConfig value_or(TextClassifierConfig const & default_value) const;
  void reset();
  TextClassifierConfig operator *();
  TextClassifierConfig operator *() const;
  TextClassifierConfig get_value();
  void set_value(TextClassifierConfig & t);

  explicit optional_TextClassifierConfig(SwigObj_inworld_optional_TextClassifierConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_TextClassifierConfig& operator=(optional_TextClassifierConfig const&) = delete;
  optional_TextClassifierConfig(optional_TextClassifierConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_TextClassifierConfig& operator=(optional_TextClassifierConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_TextClassifierConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_TextClassifierConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_TextClassifierConfig* swig_self_;
  bool swig_owns_self_;
};

class LogitBiasVector {
public:
  LogitBiasVector();
  LogitBiasVector(LogitBiasVector const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(LogitBias const & x);
  LogitBias get(int i);
  void set(int i, LogitBias const & arg3);
  ~LogitBiasVector() {
    if (swig_owns_self_)
      inworld_LogitBiasVector_delete(swig_self_);
  }

  explicit LogitBiasVector(SwigObj_inworld_LogitBiasVector* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LogitBiasVector& operator=(LogitBiasVector const&) = delete;
  LogitBiasVector(LogitBiasVector&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LogitBiasVector& operator=(LogitBiasVector&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LogitBiasVector_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LogitBiasVector* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LogitBiasVector* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_Tools {
public:
  StatusOr_Tools();
  StatusOr_Tools(Vector_Tool const & value);
  StatusOr_Tools(Status const & status);
  bool ok() const;
  Status status() const;
  Vector_Tool value() const;
  StatusOr_Tools(StatusOr_Tools const & other);
  ~StatusOr_Tools() {
    if (swig_owns_self_)
      inworld_StatusOr_Tools_delete(swig_self_);
  }

  explicit StatusOr_Tools(SwigObj_inworld_StatusOr_Tools* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_Tools& operator=(StatusOr_Tools const&) = delete;
  StatusOr_Tools(StatusOr_Tools&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_Tools& operator=(StatusOr_Tools&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_Tools_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_Tools* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_Tools* swig_self_;
  bool swig_owns_self_;
};

class Messages {
public:
  Messages();
  Messages(Messages const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Message const & x);
  Message get(int i);
  void set(int i, Message const & arg3);
  ~Messages() {
    if (swig_owns_self_)
      inworld_Messages_delete(swig_self_);
  }

  explicit Messages(SwigObj_inworld_Messages* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Messages& operator=(Messages const&) = delete;
  Messages(Messages&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Messages& operator=(Messages&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Messages_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Messages* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Messages* swig_self_;
  bool swig_owns_self_;
};

class ToolCalls {
public:
  ToolCalls();
  ToolCalls(ToolCalls const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(ToolCall const & x);
  ToolCall get(int i);
  void set(int i, ToolCall const & arg3);
  ~ToolCalls() {
    if (swig_owns_self_)
      inworld_ToolCalls_delete(swig_self_);
  }

  explicit ToolCalls(SwigObj_inworld_ToolCalls* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ToolCalls& operator=(ToolCalls const&) = delete;
  ToolCalls(ToolCalls&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ToolCalls& operator=(ToolCalls&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ToolCalls_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ToolCalls* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ToolCalls* swig_self_;
  bool swig_owns_self_;
};

class ContentItems {
public:
  ContentItems();
  ContentItems(ContentItems const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(ContentItem const & x);
  ContentItem get(int i);
  void set(int i, ContentItem const & arg3);
  ~ContentItems() {
    if (swig_owns_self_)
      inworld_ContentItems_delete(swig_self_);
  }

  explicit ContentItems(SwigObj_inworld_ContentItems* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ContentItems& operator=(ContentItems const&) = delete;
  ContentItems(ContentItems&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ContentItems& operator=(ContentItems&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ContentItems_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ContentItems* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ContentItems* swig_self_;
  bool swig_owns_self_;
};

class LogitBias {
public:
  void token_id(std::string const& token_id);
  std::string token_id() const;
  void bias_value(int bias_value);
  int bias_value() const;
  LogitBias();
  LogitBias(LogitBias const & other);
  ~LogitBias() {
    if (swig_owns_self_)
      inworld_LogitBias_delete(swig_self_);
  }

  explicit LogitBias(SwigObj_inworld_LogitBias* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LogitBias& operator=(LogitBias const&) = delete;
  LogitBias(LogitBias&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LogitBias& operator=(LogitBias&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LogitBias_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LogitBias* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LogitBias* swig_self_;
  bool swig_owns_self_;
};

class TextGenerationConfig {
public:
  void max_new_tokens(int max_new_tokens);
  int max_new_tokens() const;
  void max_prompt_length(int max_prompt_length);
  int max_prompt_length() const;
  void temperature(float temperature);
  float temperature() const;
  void top_p(float top_p);
  float top_p() const;
  void repetition_penalty(float repetition_penalty);
  float repetition_penalty() const;
  void frequency_penalty(float frequency_penalty);
  float frequency_penalty() const;
  void presence_penalty(float presence_penalty);
  float presence_penalty() const;
  void stop_sequences(vector_string * stop_sequences);
  vector_string * stop_sequences() const;
  void seed(optional_int * seed);
  optional_int * seed() const;
  void logit_bias(LogitBiasVector * logit_bias);
  LogitBiasVector * logit_bias() const;
  bool HasSeed() const;
  int GetSeed() const;
  void SetSeed(int seed_value);
  void ClearSeed();
  TextGenerationConfig();
  TextGenerationConfig(TextGenerationConfig const & other);
  ~TextGenerationConfig() {
    if (swig_owns_self_)
      inworld_TextGenerationConfig_delete(swig_self_);
  }

  explicit TextGenerationConfig(SwigObj_inworld_TextGenerationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextGenerationConfig& operator=(TextGenerationConfig const&) = delete;
  TextGenerationConfig(TextGenerationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextGenerationConfig& operator=(TextGenerationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextGenerationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextGenerationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextGenerationConfig* swig_self_;
  bool swig_owns_self_;
};

class Tool {
public:
  void name(std::string const& name);
  std::string name() const;
  void description(std::string const& description);
  std::string description() const;
  void SetPropertiesFromString(std::string const& json_str);
  std::string GetPropertiesAsString() const;
  Tool();
  Tool(Tool const & other);
  ~Tool() {
    if (swig_owns_self_)
      inworld_Tool_delete(swig_self_);
  }

  explicit Tool(SwigObj_inworld_Tool* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Tool& operator=(Tool const&) = delete;
  Tool(Tool&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Tool& operator=(Tool&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Tool_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Tool* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Tool* swig_self_;
  bool swig_owns_self_;
};

class FunctionChoice {
public:
  void type(std::string const& type);
  std::string type() const;
  void name(std::string const& name);
  std::string name() const;
  FunctionChoice();
  FunctionChoice(FunctionChoice const & other);
  ~FunctionChoice() {
    if (swig_owns_self_)
      inworld_FunctionChoice_delete(swig_self_);
  }

  explicit FunctionChoice(SwigObj_inworld_FunctionChoice* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  FunctionChoice& operator=(FunctionChoice const&) = delete;
  FunctionChoice(FunctionChoice&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  FunctionChoice& operator=(FunctionChoice&& obj) noexcept {
    if (swig_owns_self_)
      inworld_FunctionChoice_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_FunctionChoice* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_FunctionChoice* swig_self_;
  bool swig_owns_self_;
};

class ToolChoice {
public:
  bool IsStringChoice() const;
  bool IsFunctionChoice() const;
  std::string GetStringChoice() const;
  FunctionChoice GetFunctionChoice() const;
  void SetStringChoice(std::string const& choice);
  void SetFunctionChoice(FunctionChoice const & func_choice);
  ToolChoice();
  ToolChoice(ToolChoice const & other);
  ~ToolChoice() {
    if (swig_owns_self_)
      inworld_ToolChoice_delete(swig_self_);
  }

  explicit ToolChoice(SwigObj_inworld_ToolChoice* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ToolChoice& operator=(ToolChoice const&) = delete;
  ToolChoice(ToolChoice&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ToolChoice& operator=(ToolChoice&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ToolChoice_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ToolChoice* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ToolChoice* swig_self_;
  bool swig_owns_self_;
};

class ToolCall {
public:
  void id(std::string const& id);
  std::string id() const;
  void name(std::string const& name);
  std::string name() const;
  void args(std::string const& args);
  std::string args() const;
  ToolCall();
  ToolCall(ToolCall const & other);
  ~ToolCall() {
    if (swig_owns_self_)
      inworld_ToolCall_delete(swig_self_);
  }

  explicit ToolCall(SwigObj_inworld_ToolCall* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ToolCall& operator=(ToolCall const&) = delete;
  ToolCall(ToolCall&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ToolCall& operator=(ToolCall&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ToolCall_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ToolCall* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ToolCall* swig_self_;
  bool swig_owns_self_;
};

class ImageUrl {
public:
  void url(std::string const& url);
  std::string url() const;
  void detail(std::string const& detail);
  std::string detail() const;
  ImageUrl();
  ImageUrl(ImageUrl const & other);
  ~ImageUrl() {
    if (swig_owns_self_)
      inworld_ImageUrl_delete(swig_self_);
  }

  explicit ImageUrl(SwigObj_inworld_ImageUrl* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ImageUrl& operator=(ImageUrl const&) = delete;
  ImageUrl(ImageUrl&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ImageUrl& operator=(ImageUrl&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ImageUrl_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ImageUrl* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ImageUrl* swig_self_;
  bool swig_owns_self_;
};

class ContentItem {
public:
  bool IsText() const;
  bool IsImage() const;
  std::string GetText() const;
  ImageUrl GetImageUrl() const;
  void SetText(std::string const& text);
  void SetImageUrl(ImageUrl const & image_url);
  ContentItem();
  ContentItem(ContentItem const & other);
  ~ContentItem() {
    if (swig_owns_self_)
      inworld_ContentItem_delete(swig_self_);
  }

  explicit ContentItem(SwigObj_inworld_ContentItem* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ContentItem& operator=(ContentItem const&) = delete;
  ContentItem(ContentItem&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ContentItem& operator=(ContentItem&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ContentItem_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ContentItem* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ContentItem* swig_self_;
  bool swig_owns_self_;
};

class Message {
public:
  void role(std::string const& role);
  std::string role() const;
  void tool_calls(ToolCalls * tool_calls);
  ToolCalls * tool_calls() const;
  void tool_call_id(std::string const& tool_call_id);
  std::string tool_call_id() const;
  bool IsTextContent() const;
  bool IsMultimodalContent() const;
  std::string GetTextContent() const;
  ContentItems GetContentItems() const;
  void SetTextContent(std::string const& text);
  void SetContentItems(ContentItems const & content_items);
  Message();
  Message(Message const & other);
  ~Message() {
    if (swig_owns_self_)
      inworld_Message_delete(swig_self_);
  }

  explicit Message(SwigObj_inworld_Message* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Message& operator=(Message const&) = delete;
  Message(Message&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Message& operator=(Message&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Message_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Message* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Message* swig_self_;
  bool swig_owns_self_;
};

class Content {
public:
  void content(std::string const& content);
  std::string content() const;
  void tool_calls(ToolCalls * tool_calls);
  ToolCalls * tool_calls() const;
  Content();
  Content(Content const & other);
  ~Content() {
    if (swig_owns_self_)
      inworld_Content_delete(swig_self_);
  }

  explicit Content(SwigObj_inworld_Content* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Content& operator=(Content const&) = delete;
  Content(Content&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Content& operator=(Content&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Content_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Content* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Content* swig_self_;
  bool swig_owns_self_;
};

class LLMInterface : public ModelInterface {
public:
  static LLMInterface null() { return LLMInterface{(SwigObj_inworld_LLMInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~LLMInterface() {
    if (swig_owns_self_) {
      inworld_LLMInterface_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;
  StatusOr_InputStream_Content GenerateContent(std::string const& prompt) const;
  StatusOr_InputStream_Content GenerateContent(std::string const& prompt, TextGenerationConfig const & arg3) const;
  StatusOr_InputStream_Content GenerateContent(Messages const & messages, TextGenerationConfig const & arg3) const;
  StatusOr_InputStream_Content GenerateContent(Messages const & messages, Vector_Tool const & arg3) const;
  StatusOr_InputStream_Content GenerateContent(Messages const & messages, TextGenerationConfig const & arg3, Vector_Tool const & arg4) const;
  StatusOr_InputStream_Content GenerateContent(Messages const & messages, Vector_Tool const & arg3, ToolChoice const & arg4) const;
  StatusOr_InputStream_Content GenerateContent(Messages const & messages, TextGenerationConfig const & arg3, Vector_Tool const & arg4, ToolChoice const & arg5) const;

  explicit LLMInterface(SwigObj_inworld_LLMInterface* swig_self, bool swig_owns_self = true) noexcept : ModelInterface{(SwigObj_inworld_ModelInterface*)swig_self, swig_owns_self} {}
  LLMInterface(LLMInterface const&) = delete;
  LLMInterface& operator=(LLMInterface const&) = delete;
  LLMInterface(LLMInterface&& obj) = default;
  LLMInterface& operator=(LLMInterface&& obj) = default;
  SwigObj_inworld_LLMInterface* swig_self() const noexcept { return (SwigObj_inworld_LLMInterface*)ModelInterface::swig_self(); }
};

class optional_LocalLLMConfig {
public:
  optional_LocalLLMConfig();
  optional_LocalLLMConfig(LocalLLMConfig const & value);
  optional_LocalLLMConfig(optional_LocalLLMConfig const & other);
  ~optional_LocalLLMConfig() {
    if (swig_owns_self_)
      inworld_optional_LocalLLMConfig_delete(swig_self_);
  }
  bool has_value() const;
  LocalLLMConfig value();
  LocalLLMConfig value() const;
  LocalLLMConfig value_or(LocalLLMConfig const & default_value) const;
  void reset();
  LocalLLMConfig operator *();
  LocalLLMConfig operator *() const;
  LocalLLMConfig get_value();
  void set_value(LocalLLMConfig & t);

  explicit optional_LocalLLMConfig(SwigObj_inworld_optional_LocalLLMConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_LocalLLMConfig& operator=(optional_LocalLLMConfig const&) = delete;
  optional_LocalLLMConfig(optional_LocalLLMConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_LocalLLMConfig& operator=(optional_LocalLLMConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_LocalLLMConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_LocalLLMConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_LocalLLMConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_RemoteLLMConfig {
public:
  optional_RemoteLLMConfig();
  optional_RemoteLLMConfig(RemoteLLMConfig const & value);
  optional_RemoteLLMConfig(optional_RemoteLLMConfig const & other);
  ~optional_RemoteLLMConfig() {
    if (swig_owns_self_)
      inworld_optional_RemoteLLMConfig_delete(swig_self_);
  }
  bool has_value() const;
  RemoteLLMConfig value();
  RemoteLLMConfig value() const;
  RemoteLLMConfig value_or(RemoteLLMConfig const & default_value) const;
  void reset();
  RemoteLLMConfig operator *();
  RemoteLLMConfig operator *() const;
  RemoteLLMConfig get_value();
  void set_value(RemoteLLMConfig & t);

  explicit optional_RemoteLLMConfig(SwigObj_inworld_optional_RemoteLLMConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_RemoteLLMConfig& operator=(optional_RemoteLLMConfig const&) = delete;
  optional_RemoteLLMConfig(optional_RemoteLLMConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_RemoteLLMConfig& operator=(optional_RemoteLLMConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_RemoteLLMConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_RemoteLLMConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_RemoteLLMConfig* swig_self_;
  bool swig_owns_self_;
};

class LocalLLMConfig {
public:
  void model_path(std::string const& model_path);
  std::string model_path() const;
  void device(Device * device);
  Device * device() const;
  void default_config(TextGenerationConfig * default_config);
  TextGenerationConfig * default_config() const;
  LocalLLMConfig();
  LocalLLMConfig(LocalLLMConfig const & other);
  ~LocalLLMConfig() {
    if (swig_owns_self_)
      inworld_LocalLLMConfig_delete(swig_self_);
  }

  explicit LocalLLMConfig(SwigObj_inworld_LocalLLMConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LocalLLMConfig& operator=(LocalLLMConfig const&) = delete;
  LocalLLMConfig(LocalLLMConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LocalLLMConfig& operator=(LocalLLMConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LocalLLMConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LocalLLMConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LocalLLMConfig* swig_self_;
  bool swig_owns_self_;
};

class RemoteLLMConfig {
public:
  void provider(std::string const& provider);
  std::string provider() const;
  void model_name(std::string const& model_name);
  std::string model_name() const;
  void api_key(std::string const& api_key);
  std::string api_key() const;
  void default_config(TextGenerationConfig * default_config);
  TextGenerationConfig * default_config() const;
  RemoteLLMConfig();
  RemoteLLMConfig(RemoteLLMConfig const & other);
  ~RemoteLLMConfig() {
    if (swig_owns_self_)
      inworld_RemoteLLMConfig_delete(swig_self_);
  }

  explicit RemoteLLMConfig(SwigObj_inworld_RemoteLLMConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  RemoteLLMConfig& operator=(RemoteLLMConfig const&) = delete;
  RemoteLLMConfig(RemoteLLMConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  RemoteLLMConfig& operator=(RemoteLLMConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_RemoteLLMConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_RemoteLLMConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_RemoteLLMConfig* swig_self_;
  bool swig_owns_self_;
};

class LLMCreationConfig {
public:
  bool has_local_llm_config() const;
  bool has_remote_llm_config() const;
  optional_LocalLLMConfig get_local_llm_config() const;
  optional_RemoteLLMConfig get_remote_llm_config() const;
  void set_local_llm_config(LocalLLMConfig const & config);
  void set_remote_llm_config(RemoteLLMConfig const & config);
  LLMCreationConfig();
  LLMCreationConfig(LLMCreationConfig const & other);
  ~LLMCreationConfig() {
    if (swig_owns_self_)
      inworld_LLMCreationConfig_delete(swig_self_);
  }

  explicit LLMCreationConfig(SwigObj_inworld_LLMCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LLMCreationConfig& operator=(LLMCreationConfig const&) = delete;
  LLMCreationConfig(LLMCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LLMCreationConfig& operator=(LLMCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LLMCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LLMCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LLMCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class LLMFactory {
public:
  virtual ~LLMFactory() {
    if (swig_owns_self_)
      inworld_LLMFactory_delete(swig_self_);
  }
  StatusOr_LLMInterface CreateLLM(LocalLLMConfig const & config) const;
  StatusOr_LLMInterface CreateLLM(RemoteLLMConfig const & config) const;
  LLMFactory();
  LLMFactory(LLMFactory const & other);

  explicit LLMFactory(SwigObj_inworld_LLMFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LLMFactory& operator=(LLMFactory const&) = delete;
  LLMFactory(LLMFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LLMFactory& operator=(LLMFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LLMFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LLMFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LLMFactory* swig_self_;
  bool swig_owns_self_;
};

class LLMRoutingHelper {
public:
  static StatusOr_LLMRouting CreateLLMRouting(CreationContext const & creation_context, LLMRoutingCreationConfig const & arg2);
  LLMRoutingHelper();
  LLMRoutingHelper(LLMRoutingHelper const & other);
  ~LLMRoutingHelper() {
    if (swig_owns_self_)
      inworld_LLMRoutingHelper_delete(swig_self_);
  }

  explicit LLMRoutingHelper(SwigObj_inworld_LLMRoutingHelper* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LLMRoutingHelper& operator=(LLMRoutingHelper const&) = delete;
  LLMRoutingHelper(LLMRoutingHelper&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LLMRoutingHelper& operator=(LLMRoutingHelper&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LLMRoutingHelper_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LLMRoutingHelper* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LLMRoutingHelper* swig_self_;
  bool swig_owns_self_;
};

class LLMRoutingConfig {
public:
  void llm_component_id(std::string const& llm_component_id);
  std::string llm_component_id() const;
  void priority(int priority);
  int priority() const;
  void error_cooldown(Duration * error_cooldown);
  Duration * error_cooldown() const;
  void min_errors(int min_errors);
  int min_errors() const;
  LLMRoutingConfig();
  LLMRoutingConfig(LLMRoutingConfig const & other);
  ~LLMRoutingConfig() {
    if (swig_owns_self_)
      inworld_LLMRoutingConfig_delete(swig_self_);
  }

  explicit LLMRoutingConfig(SwigObj_inworld_LLMRoutingConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LLMRoutingConfig& operator=(LLMRoutingConfig const&) = delete;
  LLMRoutingConfig(LLMRoutingConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LLMRoutingConfig& operator=(LLMRoutingConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LLMRoutingConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LLMRoutingConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LLMRoutingConfig* swig_self_;
  bool swig_owns_self_;
};

class LLMRoutingCreationConfig {
public:
  void routing_configs(vector_LLMRoutingConfig * routing_configs);
  vector_LLMRoutingConfig * routing_configs() const;
  LLMRoutingCreationConfig();
  LLMRoutingCreationConfig(LLMRoutingCreationConfig const & other);
  ~LLMRoutingCreationConfig() {
    if (swig_owns_self_)
      inworld_LLMRoutingCreationConfig_delete(swig_self_);
  }

  explicit LLMRoutingCreationConfig(SwigObj_inworld_LLMRoutingCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LLMRoutingCreationConfig& operator=(LLMRoutingCreationConfig const&) = delete;
  LLMRoutingCreationConfig(LLMRoutingCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LLMRoutingCreationConfig& operator=(LLMRoutingCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LLMRoutingCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LLMRoutingCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LLMRoutingCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class LLMRouting : public LLMInterface {
public:
  static LLMRouting null() { return LLMRouting{(SwigObj_inworld_LLMRouting*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;

  explicit LLMRouting(SwigObj_inworld_LLMRouting* swig_self, bool swig_owns_self = true) noexcept : LLMInterface{(SwigObj_inworld_LLMInterface*)swig_self, swig_owns_self} {}
  LLMRouting(LLMRouting const&) = delete;
  LLMRouting& operator=(LLMRouting const&) = delete;
  LLMRouting(LLMRouting&& obj) = default;
  LLMRouting& operator=(LLMRouting&& obj) = default;
  SwigObj_inworld_LLMRouting* swig_self() const noexcept { return (SwigObj_inworld_LLMRouting*)LLMInterface::swig_self(); }
};

class KnowledgeRecord {
public:
  void text(std::string const& text);
  std::string text() const;
  void embedding(vector_float * embedding);
  vector_float * embedding() const;
  void metadata(vector_string * metadata);
  vector_string * metadata() const;
  KnowledgeRecord();
  KnowledgeRecord(KnowledgeRecord const & other);
  ~KnowledgeRecord() {
    if (swig_owns_self_)
      inworld_KnowledgeRecord_delete(swig_self_);
  }

  explicit KnowledgeRecord(SwigObj_inworld_KnowledgeRecord* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KnowledgeRecord& operator=(KnowledgeRecord const&) = delete;
  KnowledgeRecord(KnowledgeRecord&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KnowledgeRecord& operator=(KnowledgeRecord&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KnowledgeRecord_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KnowledgeRecord* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KnowledgeRecord* swig_self_;
  bool swig_owns_self_;
};

class KnowledgeCollection {
public:
  void knowledge_records(vector_KnowledgeRecord * knowledge_records);
  vector_KnowledgeRecord * knowledge_records() const;
  KnowledgeCollection();
  KnowledgeCollection(KnowledgeCollection const & other);
  ~KnowledgeCollection() {
    if (swig_owns_self_)
      inworld_KnowledgeCollection_delete(swig_self_);
  }

  explicit KnowledgeCollection(SwigObj_inworld_KnowledgeCollection* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KnowledgeCollection& operator=(KnowledgeCollection const&) = delete;
  KnowledgeCollection(KnowledgeCollection&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KnowledgeCollection& operator=(KnowledgeCollection&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KnowledgeCollection_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KnowledgeCollection* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KnowledgeCollection* swig_self_;
  bool swig_owns_self_;
};

class RetrievalConfig {
public:
  void threshold(float threshold);
  float threshold() const;
  void top_k(int top_k);
  int top_k() const;
  RetrievalConfig();
  RetrievalConfig(RetrievalConfig const & other);
  ~RetrievalConfig() {
    if (swig_owns_self_)
      inworld_RetrievalConfig_delete(swig_self_);
  }

  explicit RetrievalConfig(SwigObj_inworld_RetrievalConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  RetrievalConfig& operator=(RetrievalConfig const&) = delete;
  RetrievalConfig(RetrievalConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  RetrievalConfig& operator=(RetrievalConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_RetrievalConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_RetrievalConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_RetrievalConfig* swig_self_;
  bool swig_owns_self_;
};

class KnowledgeRetrieverInterface {
public:
  static KnowledgeRetrieverInterface null() { return KnowledgeRetrieverInterface{(SwigObj_inworld_KnowledgeRetrieverInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~KnowledgeRetrieverInterface() {
    if (swig_owns_self_)
      inworld_KnowledgeRetrieverInterface_delete(swig_self_);
  }
  bool is_valid() const;
  StatusOr_vector_string RetrieveKnowledge(RetrievalConfig const & config, vector_KnowledgeCollection const & arg3, vector_Event const & arg4) const;

  explicit KnowledgeRetrieverInterface(SwigObj_inworld_KnowledgeRetrieverInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KnowledgeRetrieverInterface(KnowledgeRetrieverInterface const&) = delete;
  KnowledgeRetrieverInterface& operator=(KnowledgeRetrieverInterface const&) = delete;
  KnowledgeRetrieverInterface(KnowledgeRetrieverInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KnowledgeRetrieverInterface& operator=(KnowledgeRetrieverInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KnowledgeRetrieverInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KnowledgeRetrieverInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KnowledgeRetrieverInterface* swig_self_;
  bool swig_owns_self_;
};

class File {
public:
  enum class Type  {
    kPdf,
    kTxt
  };

  void content(FileContent * content);
  FileContent * content() const;
  void type(File::Type type);
  File::Type type() const;
  File();
  File(File const & other);
  ~File() {
    if (swig_owns_self_)
      inworld_File_delete(swig_self_);
  }

  explicit File(SwigObj_inworld_File* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  File& operator=(File const&) = delete;
  File(File&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  File& operator=(File&& obj) noexcept {
    if (swig_owns_self_)
      inworld_File_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_File* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_File* swig_self_;
  bool swig_owns_self_;
};

class FileContent {
public:
  void bytes(vector_char * bytes);
  vector_char * bytes() const;
  FileContent();
  FileContent(FileContent const & other);
  ~FileContent() {
    if (swig_owns_self_)
      inworld_FileContent_delete(swig_self_);
  }

  explicit FileContent(SwigObj_inworld_FileContent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  FileContent& operator=(FileContent const&) = delete;
  FileContent(FileContent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  FileContent& operator=(FileContent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_FileContent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_FileContent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_FileContent* swig_self_;
  bool swig_owns_self_;
};

class ParsingConfig {
public:
  void max_chars_per_chunk(int max_chars_per_chunk);
  int max_chars_per_chunk() const;
  void max_chunks_per_document(int max_chunks_per_document);
  int max_chunks_per_document() const;
  ParsingConfig();
  ParsingConfig(ParsingConfig const & other);
  ~ParsingConfig() {
    if (swig_owns_self_)
      inworld_ParsingConfig_delete(swig_self_);
  }

  explicit ParsingConfig(SwigObj_inworld_ParsingConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ParsingConfig& operator=(ParsingConfig const&) = delete;
  ParsingConfig(ParsingConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ParsingConfig& operator=(ParsingConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ParsingConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ParsingConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ParsingConfig* swig_self_;
  bool swig_owns_self_;
};

class KnowledgeCompileConfig {
public:
  void parsing_config(ParsingConfig * parsing_config);
  ParsingConfig * parsing_config() const;
  KnowledgeCompileConfig();
  KnowledgeCompileConfig(KnowledgeCompileConfig const & other);
  ~KnowledgeCompileConfig() {
    if (swig_owns_self_)
      inworld_KnowledgeCompileConfig_delete(swig_self_);
  }

  explicit KnowledgeCompileConfig(SwigObj_inworld_KnowledgeCompileConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KnowledgeCompileConfig& operator=(KnowledgeCompileConfig const&) = delete;
  KnowledgeCompileConfig(KnowledgeCompileConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KnowledgeCompileConfig& operator=(KnowledgeCompileConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KnowledgeCompileConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KnowledgeCompileConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KnowledgeCompileConfig* swig_self_;
  bool swig_owns_self_;
};

class KnowledgeInterface {
public:
  static KnowledgeInterface null() { return KnowledgeInterface{(SwigObj_inworld_KnowledgeInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~KnowledgeInterface() {
    if (swig_owns_self_)
      inworld_KnowledgeInterface_delete(swig_self_);
  }
  virtual Status RemoveKnowledge(std::string const& knowledge_id) const;
  bool is_valid() const;
  StatusOr_vector_string GetKnowledge(vector_string const & ids, vector_Event const & arg3) const;
  StatusOr_vector_string CompileKnowledge(std::string const& knowledge_id, vector_string const & arg3) const;
  StatusOr_vector_string CompileKnowledge(std::string const& knowledge_id, vector_char const& arg3, File::Type arg4) const;

  explicit KnowledgeInterface(SwigObj_inworld_KnowledgeInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KnowledgeInterface(KnowledgeInterface const&) = delete;
  KnowledgeInterface& operator=(KnowledgeInterface const&) = delete;
  KnowledgeInterface(KnowledgeInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KnowledgeInterface& operator=(KnowledgeInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KnowledgeInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KnowledgeInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KnowledgeInterface* swig_self_;
  bool swig_owns_self_;
};

class optional_LocalKnowledgeConfig {
public:
  optional_LocalKnowledgeConfig();
  optional_LocalKnowledgeConfig(LocalKnowledgeConfig const & value);
  optional_LocalKnowledgeConfig(optional_LocalKnowledgeConfig const & other);
  ~optional_LocalKnowledgeConfig() {
    if (swig_owns_self_)
      inworld_optional_LocalKnowledgeConfig_delete(swig_self_);
  }
  bool has_value() const;
  LocalKnowledgeConfig value();
  LocalKnowledgeConfig value() const;
  LocalKnowledgeConfig value_or(LocalKnowledgeConfig const & default_value) const;
  void reset();
  LocalKnowledgeConfig operator *();
  LocalKnowledgeConfig operator *() const;
  LocalKnowledgeConfig get_value();
  void set_value(LocalKnowledgeConfig & t);

  explicit optional_LocalKnowledgeConfig(SwigObj_inworld_optional_LocalKnowledgeConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_LocalKnowledgeConfig& operator=(optional_LocalKnowledgeConfig const&) = delete;
  optional_LocalKnowledgeConfig(optional_LocalKnowledgeConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_LocalKnowledgeConfig& operator=(optional_LocalKnowledgeConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_LocalKnowledgeConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_LocalKnowledgeConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_LocalKnowledgeConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_RemoteKnowledgeConfig {
public:
  optional_RemoteKnowledgeConfig();
  optional_RemoteKnowledgeConfig(RemoteKnowledgeConfig const & value);
  optional_RemoteKnowledgeConfig(optional_RemoteKnowledgeConfig const & other);
  ~optional_RemoteKnowledgeConfig() {
    if (swig_owns_self_)
      inworld_optional_RemoteKnowledgeConfig_delete(swig_self_);
  }
  bool has_value() const;
  RemoteKnowledgeConfig value();
  RemoteKnowledgeConfig value() const;
  RemoteKnowledgeConfig value_or(RemoteKnowledgeConfig const & default_value) const;
  void reset();
  RemoteKnowledgeConfig operator *();
  RemoteKnowledgeConfig operator *() const;
  RemoteKnowledgeConfig get_value();
  void set_value(RemoteKnowledgeConfig & t);

  explicit optional_RemoteKnowledgeConfig(SwigObj_inworld_optional_RemoteKnowledgeConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_RemoteKnowledgeConfig& operator=(optional_RemoteKnowledgeConfig const&) = delete;
  optional_RemoteKnowledgeConfig(optional_RemoteKnowledgeConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_RemoteKnowledgeConfig& operator=(optional_RemoteKnowledgeConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_RemoteKnowledgeConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_RemoteKnowledgeConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_RemoteKnowledgeConfig* swig_self_;
  bool swig_owns_self_;
};

class LocalKnowledgeConfig {
public:
  void knowledge_compile_config(KnowledgeCompileConfig * knowledge_compile_config);
  KnowledgeCompileConfig * knowledge_compile_config() const;
  void embedder_component_id(std::string const& embedder_component_id);
  std::string embedder_component_id() const;
  LocalKnowledgeConfig();
  LocalKnowledgeConfig(LocalKnowledgeConfig const & other);
  ~LocalKnowledgeConfig() {
    if (swig_owns_self_)
      inworld_LocalKnowledgeConfig_delete(swig_self_);
  }

  explicit LocalKnowledgeConfig(SwigObj_inworld_LocalKnowledgeConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LocalKnowledgeConfig& operator=(LocalKnowledgeConfig const&) = delete;
  LocalKnowledgeConfig(LocalKnowledgeConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LocalKnowledgeConfig& operator=(LocalKnowledgeConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LocalKnowledgeConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LocalKnowledgeConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LocalKnowledgeConfig* swig_self_;
  bool swig_owns_self_;
};

class RemoteKnowledgeConfig {
public:
  void knowledge_compile_config(KnowledgeCompileConfig * knowledge_compile_config);
  KnowledgeCompileConfig * knowledge_compile_config() const;
  void api_key(std::string const& api_key);
  std::string api_key() const;
  void language(Language * language);
  Language * language() const;
  RemoteKnowledgeConfig();
  RemoteKnowledgeConfig(RemoteKnowledgeConfig const & other);
  ~RemoteKnowledgeConfig() {
    if (swig_owns_self_)
      inworld_RemoteKnowledgeConfig_delete(swig_self_);
  }

  explicit RemoteKnowledgeConfig(SwigObj_inworld_RemoteKnowledgeConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  RemoteKnowledgeConfig& operator=(RemoteKnowledgeConfig const&) = delete;
  RemoteKnowledgeConfig(RemoteKnowledgeConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  RemoteKnowledgeConfig& operator=(RemoteKnowledgeConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_RemoteKnowledgeConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_RemoteKnowledgeConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_RemoteKnowledgeConfig* swig_self_;
  bool swig_owns_self_;
};

class KnowledgeCreationConfig {
public:
  bool has_local_config();
  bool has_remote_config();
  optional_LocalKnowledgeConfig get_local_config();
  optional_RemoteKnowledgeConfig get_remote_config();
  void set_local_config(LocalKnowledgeConfig const & config);
  void set_remote_config(RemoteKnowledgeConfig const & config);
  bool is_valid() const;
  KnowledgeCreationConfig();
  KnowledgeCreationConfig(KnowledgeCreationConfig const & other);
  ~KnowledgeCreationConfig() {
    if (swig_owns_self_)
      inworld_KnowledgeCreationConfig_delete(swig_self_);
  }

  explicit KnowledgeCreationConfig(SwigObj_inworld_KnowledgeCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KnowledgeCreationConfig& operator=(KnowledgeCreationConfig const&) = delete;
  KnowledgeCreationConfig(KnowledgeCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KnowledgeCreationConfig& operator=(KnowledgeCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KnowledgeCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KnowledgeCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KnowledgeCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class KnowledgeFactory {
public:
  virtual ~KnowledgeFactory() {
    if (swig_owns_self_)
      inworld_KnowledgeFactory_delete(swig_self_);
  }
  StatusOr_KnowledgeInterface CreateKnowledge(CreationContext const & creation_context, LocalKnowledgeConfig const & arg3) const;
  StatusOr_KnowledgeInterface CreateKnowledge(CreationContext const & creation_context, RemoteKnowledgeConfig const & arg3) const;
  KnowledgeFactory();
  KnowledgeFactory(KnowledgeFactory const & other);

  explicit KnowledgeFactory(SwigObj_inworld_KnowledgeFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KnowledgeFactory& operator=(KnowledgeFactory const&) = delete;
  KnowledgeFactory(KnowledgeFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KnowledgeFactory& operator=(KnowledgeFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KnowledgeFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KnowledgeFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KnowledgeFactory* swig_self_;
  bool swig_owns_self_;
};

class KnowledgeCollectionFactory {
public:
  virtual ~KnowledgeCollectionFactory() {
    if (swig_owns_self_)
      inworld_KnowledgeCollectionFactory_delete(swig_self_);
  }
  KnowledgeCollection CreateKnowledgeCollection(TextEmbedderInterface const& embedder, vector_string const & arg3) const;
  KnowledgeCollectionFactory();
  KnowledgeCollectionFactory(KnowledgeCollectionFactory const & other);

  explicit KnowledgeCollectionFactory(SwigObj_inworld_KnowledgeCollectionFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KnowledgeCollectionFactory& operator=(KnowledgeCollectionFactory const&) = delete;
  KnowledgeCollectionFactory(KnowledgeCollectionFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KnowledgeCollectionFactory& operator=(KnowledgeCollectionFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KnowledgeCollectionFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KnowledgeCollectionFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KnowledgeCollectionFactory* swig_self_;
  bool swig_owns_self_;
};

class KnowledgeRetrieverFactory {
public:
  virtual ~KnowledgeRetrieverFactory() {
    if (swig_owns_self_)
      inworld_KnowledgeRetrieverFactory_delete(swig_self_);
  }
  StatusOr_KnowledgeRetrieverInterface CreateKnowledgeRetriever(TextEmbedderInterface const& embedder) const;
  KnowledgeRetrieverFactory();
  KnowledgeRetrieverFactory(KnowledgeRetrieverFactory const & other);

  explicit KnowledgeRetrieverFactory(SwigObj_inworld_KnowledgeRetrieverFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KnowledgeRetrieverFactory& operator=(KnowledgeRetrieverFactory const&) = delete;
  KnowledgeRetrieverFactory(KnowledgeRetrieverFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KnowledgeRetrieverFactory& operator=(KnowledgeRetrieverFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KnowledgeRetrieverFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KnowledgeRetrieverFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KnowledgeRetrieverFactory* swig_self_;
  bool swig_owns_self_;
};

class optional_RollingSummaryConfig {
public:
  optional_RollingSummaryConfig();
  optional_RollingSummaryConfig(RollingSummaryConfig const & value);
  optional_RollingSummaryConfig(optional_RollingSummaryConfig const & other);
  ~optional_RollingSummaryConfig() {
    if (swig_owns_self_)
      inworld_optional_RollingSummaryConfig_delete(swig_self_);
  }
  bool has_value() const;
  RollingSummaryConfig value();
  RollingSummaryConfig value() const;
  RollingSummaryConfig value_or(RollingSummaryConfig const & default_value) const;
  void reset();
  RollingSummaryConfig operator *();
  RollingSummaryConfig operator *() const;
  RollingSummaryConfig get_value();
  void set_value(RollingSummaryConfig & t);

  explicit optional_RollingSummaryConfig(SwigObj_inworld_optional_RollingSummaryConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_RollingSummaryConfig& operator=(optional_RollingSummaryConfig const&) = delete;
  optional_RollingSummaryConfig(optional_RollingSummaryConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_RollingSummaryConfig& operator=(optional_RollingSummaryConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_RollingSummaryConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_RollingSummaryConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_RollingSummaryConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_FlashMemoryConfig {
public:
  optional_FlashMemoryConfig();
  optional_FlashMemoryConfig(FlashMemoryConfig const & value);
  optional_FlashMemoryConfig(optional_FlashMemoryConfig const & other);
  ~optional_FlashMemoryConfig() {
    if (swig_owns_self_)
      inworld_optional_FlashMemoryConfig_delete(swig_self_);
  }
  bool has_value() const;
  FlashMemoryConfig value();
  FlashMemoryConfig value() const;
  FlashMemoryConfig value_or(FlashMemoryConfig const & default_value) const;
  void reset();
  FlashMemoryConfig operator *();
  FlashMemoryConfig operator *() const;
  FlashMemoryConfig get_value();
  void set_value(FlashMemoryConfig & t);

  explicit optional_FlashMemoryConfig(SwigObj_inworld_optional_FlashMemoryConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_FlashMemoryConfig& operator=(optional_FlashMemoryConfig const&) = delete;
  optional_FlashMemoryConfig(optional_FlashMemoryConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_FlashMemoryConfig& operator=(optional_FlashMemoryConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_FlashMemoryConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_FlashMemoryConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_FlashMemoryConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_LongTermMemoryConfig {
public:
  optional_LongTermMemoryConfig();
  optional_LongTermMemoryConfig(LongTermMemoryConfig const & value);
  optional_LongTermMemoryConfig(optional_LongTermMemoryConfig const & other);
  ~optional_LongTermMemoryConfig() {
    if (swig_owns_self_)
      inworld_optional_LongTermMemoryConfig_delete(swig_self_);
  }
  bool has_value() const;
  LongTermMemoryConfig value();
  LongTermMemoryConfig value() const;
  LongTermMemoryConfig value_or(LongTermMemoryConfig const & default_value) const;
  void reset();
  LongTermMemoryConfig operator *();
  LongTermMemoryConfig operator *() const;
  LongTermMemoryConfig get_value();
  void set_value(LongTermMemoryConfig & t);

  explicit optional_LongTermMemoryConfig(SwigObj_inworld_optional_LongTermMemoryConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_LongTermMemoryConfig& operator=(optional_LongTermMemoryConfig const&) = delete;
  optional_LongTermMemoryConfig(optional_LongTermMemoryConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_LongTermMemoryConfig& operator=(optional_LongTermMemoryConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_LongTermMemoryConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_LongTermMemoryConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_LongTermMemoryConfig* swig_self_;
  bool swig_owns_self_;
};

class RollingSummary {
public:
  void summarized_text(std::string const& summarized_text);
  std::string summarized_text() const;
  void turns_since_last_update(int turns_since_last_update);
  int turns_since_last_update() const;
  RollingSummary();
  RollingSummary(RollingSummary const & other);
  ~RollingSummary() {
    if (swig_owns_self_)
      inworld_RollingSummary_delete(swig_self_);
  }

  explicit RollingSummary(SwigObj_inworld_RollingSummary* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  RollingSummary& operator=(RollingSummary const&) = delete;
  RollingSummary(RollingSummary&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  RollingSummary& operator=(RollingSummary&& obj) noexcept {
    if (swig_owns_self_)
      inworld_RollingSummary_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_RollingSummary* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_RollingSummary* swig_self_;
  bool swig_owns_self_;
};

class FlashMemory {
public:
  void knowledge_collection(KnowledgeCollection * knowledge_collection);
  KnowledgeCollection * knowledge_collection() const;
  FlashMemory();
  FlashMemory(FlashMemory const & other);
  ~FlashMemory() {
    if (swig_owns_self_)
      inworld_FlashMemory_delete(swig_self_);
  }

  explicit FlashMemory(SwigObj_inworld_FlashMemory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  FlashMemory& operator=(FlashMemory const&) = delete;
  FlashMemory(FlashMemory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  FlashMemory& operator=(FlashMemory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_FlashMemory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_FlashMemory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_FlashMemory* swig_self_;
  bool swig_owns_self_;
};

class LongTermMemory {
public:
  void knowledge_collection(KnowledgeCollection * knowledge_collection);
  KnowledgeCollection * knowledge_collection() const;
  LongTermMemory();
  LongTermMemory(LongTermMemory const & other);
  ~LongTermMemory() {
    if (swig_owns_self_)
      inworld_LongTermMemory_delete(swig_self_);
  }

  explicit LongTermMemory(SwigObj_inworld_LongTermMemory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LongTermMemory& operator=(LongTermMemory const&) = delete;
  LongTermMemory(LongTermMemory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LongTermMemory& operator=(LongTermMemory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LongTermMemory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LongTermMemory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LongTermMemory* swig_self_;
  bool swig_owns_self_;
};

class MemorySnapshot {
public:
  void rolling_summary(RollingSummary * rolling_summary);
  RollingSummary * rolling_summary() const;
  void flash_memory(FlashMemory * flash_memory);
  FlashMemory * flash_memory() const;
  void long_term_memory(LongTermMemory * long_term_memory);
  LongTermMemory * long_term_memory() const;
  MemorySnapshot();
  MemorySnapshot(MemorySnapshot const & other);
  ~MemorySnapshot() {
    if (swig_owns_self_)
      inworld_MemorySnapshot_delete(swig_self_);
  }

  explicit MemorySnapshot(SwigObj_inworld_MemorySnapshot* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MemorySnapshot& operator=(MemorySnapshot const&) = delete;
  MemorySnapshot(MemorySnapshot&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MemorySnapshot& operator=(MemorySnapshot&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MemorySnapshot_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MemorySnapshot* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MemorySnapshot* swig_self_;
  bool swig_owns_self_;
};

class RollingSummaryConfig {
public:
  void number_of_turns_before_summary(int number_of_turns_before_summary);
  int number_of_turns_before_summary() const;
  void start_window_size(int start_window_size);
  int start_window_size() const;
  void text_generation_config(TextGenerationConfig * text_generation_config);
  TextGenerationConfig * text_generation_config() const;
  void max_summary_sentences(int max_summary_sentences);
  int max_summary_sentences() const;
  RollingSummaryConfig();
  RollingSummaryConfig(RollingSummaryConfig const & other);
  ~RollingSummaryConfig() {
    if (swig_owns_self_)
      inworld_RollingSummaryConfig_delete(swig_self_);
  }

  explicit RollingSummaryConfig(SwigObj_inworld_RollingSummaryConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  RollingSummaryConfig& operator=(RollingSummaryConfig const&) = delete;
  RollingSummaryConfig(RollingSummaryConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  RollingSummaryConfig& operator=(RollingSummaryConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_RollingSummaryConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_RollingSummaryConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_RollingSummaryConfig* swig_self_;
  bool swig_owns_self_;
};

class FlashMemoryConfig {
public:
  void dialogue_cutoff_size(int dialogue_cutoff_size);
  int dialogue_cutoff_size() const;
  void n_history_turns(int n_history_turns);
  int n_history_turns() const;
  void memories_similarity_threshold(float memories_similarity_threshold);
  float memories_similarity_threshold() const;
  void max_flash_memory(int max_flash_memory);
  int max_flash_memory() const;
  void max_topics_per_memory(int max_topics_per_memory);
  int max_topics_per_memory() const;
  void text_generation_config(TextGenerationConfig * text_generation_config);
  TextGenerationConfig * text_generation_config() const;
  FlashMemoryConfig();
  FlashMemoryConfig(FlashMemoryConfig const & other);
  ~FlashMemoryConfig() {
    if (swig_owns_self_)
      inworld_FlashMemoryConfig_delete(swig_self_);
  }

  explicit FlashMemoryConfig(SwigObj_inworld_FlashMemoryConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  FlashMemoryConfig& operator=(FlashMemoryConfig const&) = delete;
  FlashMemoryConfig(FlashMemoryConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  FlashMemoryConfig& operator=(FlashMemoryConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_FlashMemoryConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_FlashMemoryConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_FlashMemoryConfig* swig_self_;
  bool swig_owns_self_;
};

class LongTermMemoryConfig {
public:
  void max_topic_summary_len_to_append(int max_topic_summary_len_to_append);
  int max_topic_summary_len_to_append() const;
  void max_number_of_flash_memory(int max_number_of_flash_memory);
  int max_number_of_flash_memory() const;
  void max_number_of_topics(int max_number_of_topics);
  int max_number_of_topics() const;
  void text_generation_config(TextGenerationConfig * text_generation_config);
  TextGenerationConfig * text_generation_config() const;
  LongTermMemoryConfig();
  LongTermMemoryConfig(LongTermMemoryConfig const & other);
  ~LongTermMemoryConfig() {
    if (swig_owns_self_)
      inworld_LongTermMemoryConfig_delete(swig_self_);
  }

  explicit LongTermMemoryConfig(SwigObj_inworld_LongTermMemoryConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LongTermMemoryConfig& operator=(LongTermMemoryConfig const&) = delete;
  LongTermMemoryConfig(LongTermMemoryConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LongTermMemoryConfig& operator=(LongTermMemoryConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LongTermMemoryConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LongTermMemoryConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LongTermMemoryConfig* swig_self_;
  bool swig_owns_self_;
};

class MemoryUpdateConfig {
public:
  void rolling_summary_config(optional_RollingSummaryConfig * rolling_summary_config);
  optional_RollingSummaryConfig * rolling_summary_config() const;
  void flash_memory_config(optional_FlashMemoryConfig * flash_memory_config);
  optional_FlashMemoryConfig * flash_memory_config() const;
  void long_term_memory_config(optional_LongTermMemoryConfig * long_term_memory_config);
  optional_LongTermMemoryConfig * long_term_memory_config() const;
  MemoryUpdateConfig();
  MemoryUpdateConfig(MemoryUpdateConfig const & other);
  ~MemoryUpdateConfig() {
    if (swig_owns_self_)
      inworld_MemoryUpdateConfig_delete(swig_self_);
  }

  explicit MemoryUpdateConfig(SwigObj_inworld_MemoryUpdateConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MemoryUpdateConfig& operator=(MemoryUpdateConfig const&) = delete;
  MemoryUpdateConfig(MemoryUpdateConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MemoryUpdateConfig& operator=(MemoryUpdateConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MemoryUpdateConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MemoryUpdateConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MemoryUpdateConfig* swig_self_;
  bool swig_owns_self_;
};

class MemoryInterface {
public:
  static MemoryInterface null() { return MemoryInterface{(SwigObj_inworld_MemoryInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~MemoryInterface() {
    if (swig_owns_self_)
      inworld_MemoryInterface_delete(swig_self_);
  }
  bool is_valid() const;
  StatusOr_vector_string GetMemory(vector_Event const & event_history, MemorySnapshot const & arg3, RetrievalConfig const & arg4, bool arg5) const;
  StatusOr_vector_string GetMemory(vector_Event const & event_history, MemorySnapshot const & arg3, RetrievalConfig const & arg4) const;
  StatusOr_MemorySnapshot UpdateMemory(vector_Event const & event_history, MemorySnapshot const & arg3) const;

  explicit MemoryInterface(SwigObj_inworld_MemoryInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MemoryInterface(MemoryInterface const&) = delete;
  MemoryInterface& operator=(MemoryInterface const&) = delete;
  MemoryInterface(MemoryInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MemoryInterface& operator=(MemoryInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MemoryInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MemoryInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MemoryInterface* swig_self_;
  bool swig_owns_self_;
};

class MemoryFactory {
public:
  virtual ~MemoryFactory() {
    if (swig_owns_self_)
      inworld_MemoryFactory_delete(swig_self_);
  }
  StatusOr_MemoryInterface CreateMemory(LLMInterface const& llm, TextEmbedderInterface const& arg3, RollingSummaryConfig & arg4, FlashMemoryConfig & arg5, LongTermMemoryConfig & arg6, RetrievalConfig & arg7, bool arg8) const;
  MemoryFactory();
  MemoryFactory(MemoryFactory const & other);

  explicit MemoryFactory(SwigObj_inworld_MemoryFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MemoryFactory& operator=(MemoryFactory const&) = delete;
  MemoryFactory(MemoryFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MemoryFactory& operator=(MemoryFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MemoryFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MemoryFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MemoryFactory* swig_self_;
  bool swig_owns_self_;
};

class IntentCompilerInterface {
public:
  static IntentCompilerInterface null() { return IntentCompilerInterface{(SwigObj_inworld_IntentCompilerInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~IntentCompilerInterface() {
    if (swig_owns_self_)
      inworld_IntentCompilerInterface_delete(swig_self_);
  }
  virtual StatusOr_vector_CompiledIntent CompileIntents(vector_Intent const & intents) const;
  bool is_valid() const;

  explicit IntentCompilerInterface(SwigObj_inworld_IntentCompilerInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  IntentCompilerInterface(IntentCompilerInterface const&) = delete;
  IntentCompilerInterface& operator=(IntentCompilerInterface const&) = delete;
  IntentCompilerInterface(IntentCompilerInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  IntentCompilerInterface& operator=(IntentCompilerInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_IntentCompilerInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_IntentCompilerInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_IntentCompilerInterface* swig_self_;
  bool swig_owns_self_;
};

class IntentCompilerFactory {
public:
  virtual ~IntentCompilerFactory() {
    if (swig_owns_self_)
      inworld_IntentCompilerFactory_delete(swig_self_);
  }
  StatusOr_IntentCompilerInterface CreateIntentCompiler(TextEmbedderInterface const& embedder) const;
  StatusOr_IntentCompilerInterface CreateIntentCompiler() const;
  IntentCompilerFactory();
  IntentCompilerFactory(IntentCompilerFactory const & other);

  explicit IntentCompilerFactory(SwigObj_inworld_IntentCompilerFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  IntentCompilerFactory& operator=(IntentCompilerFactory const&) = delete;
  IntentCompilerFactory(IntentCompilerFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  IntentCompilerFactory& operator=(IntentCompilerFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_IntentCompilerFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_IntentCompilerFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_IntentCompilerFactory* swig_self_;
  bool swig_owns_self_;
};

class optional_LlmMatcherConfig {
public:
  optional_LlmMatcherConfig();
  optional_LlmMatcherConfig(LlmMatcherConfig const & value);
  optional_LlmMatcherConfig(optional_LlmMatcherConfig const & other);
  ~optional_LlmMatcherConfig() {
    if (swig_owns_self_)
      inworld_optional_LlmMatcherConfig_delete(swig_self_);
  }
  bool has_value() const;
  LlmMatcherConfig value();
  LlmMatcherConfig value() const;
  LlmMatcherConfig value_or(LlmMatcherConfig const & default_value) const;
  void reset();
  LlmMatcherConfig operator *();
  LlmMatcherConfig operator *() const;
  LlmMatcherConfig get_value();
  void set_value(LlmMatcherConfig & t);

  explicit optional_LlmMatcherConfig(SwigObj_inworld_optional_LlmMatcherConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_LlmMatcherConfig& operator=(optional_LlmMatcherConfig const&) = delete;
  optional_LlmMatcherConfig(optional_LlmMatcherConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_LlmMatcherConfig& operator=(optional_LlmMatcherConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_LlmMatcherConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_LlmMatcherConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_LlmMatcherConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_TextEmbedderInterface {
public:
  optional_TextEmbedderInterface();
  optional_TextEmbedderInterface(TextEmbedderInterface const& value);
  optional_TextEmbedderInterface(optional_TextEmbedderInterface const & other);
  ~optional_TextEmbedderInterface() {
    if (swig_owns_self_)
      inworld_optional_TextEmbedderInterface_delete(swig_self_);
  }
  bool has_value() const;
  TextEmbedderInterface value();
  TextEmbedderInterface value() const;
  TextEmbedderInterface value_or(TextEmbedderInterface const& default_value) const;
  void reset();
  TextEmbedderInterface operator *();
  TextEmbedderInterface operator *() const;
  TextEmbedderInterface get_value();
  void set_value(TextEmbedderInterface const& t);

  explicit optional_TextEmbedderInterface(SwigObj_inworld_optional_TextEmbedderInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_TextEmbedderInterface& operator=(optional_TextEmbedderInterface const&) = delete;
  optional_TextEmbedderInterface(optional_TextEmbedderInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_TextEmbedderInterface& operator=(optional_TextEmbedderInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_TextEmbedderInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_TextEmbedderInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_TextEmbedderInterface* swig_self_;
  bool swig_owns_self_;
};

class optional_EmbeddingMatcherConfig {
public:
  optional_EmbeddingMatcherConfig();
  optional_EmbeddingMatcherConfig(EmbeddingMatcherConfig const & value);
  optional_EmbeddingMatcherConfig(optional_EmbeddingMatcherConfig const & other);
  ~optional_EmbeddingMatcherConfig() {
    if (swig_owns_self_)
      inworld_optional_EmbeddingMatcherConfig_delete(swig_self_);
  }
  bool has_value() const;
  EmbeddingMatcherConfig value();
  EmbeddingMatcherConfig value() const;
  EmbeddingMatcherConfig value_or(EmbeddingMatcherConfig const & default_value) const;
  void reset();
  EmbeddingMatcherConfig operator *();
  EmbeddingMatcherConfig operator *() const;
  EmbeddingMatcherConfig get_value();
  void set_value(EmbeddingMatcherConfig & t);

  explicit optional_EmbeddingMatcherConfig(SwigObj_inworld_optional_EmbeddingMatcherConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_EmbeddingMatcherConfig& operator=(optional_EmbeddingMatcherConfig const&) = delete;
  optional_EmbeddingMatcherConfig(optional_EmbeddingMatcherConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_EmbeddingMatcherConfig& operator=(optional_EmbeddingMatcherConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_EmbeddingMatcherConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_EmbeddingMatcherConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_EmbeddingMatcherConfig* swig_self_;
  bool swig_owns_self_;
};

class IntentMatch {
public:
  void intent_name(std::string const& intent_name);
  std::string intent_name() const;
  void score(float score);
  float score() const;
  IntentMatch();
  IntentMatch(IntentMatch const & other);
  ~IntentMatch() {
    if (swig_owns_self_)
      inworld_IntentMatch_delete(swig_self_);
  }

  explicit IntentMatch(SwigObj_inworld_IntentMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  IntentMatch& operator=(IntentMatch const&) = delete;
  IntentMatch(IntentMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  IntentMatch& operator=(IntentMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_IntentMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_IntentMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_IntentMatch* swig_self_;
  bool swig_owns_self_;
};

class EmbeddingMatcherConfig {
public:
  void similarity_threshold(float similarity_threshold);
  float similarity_threshold() const;
  EmbeddingMatcherConfig();
  EmbeddingMatcherConfig(EmbeddingMatcherConfig const & other);
  ~EmbeddingMatcherConfig() {
    if (swig_owns_self_)
      inworld_EmbeddingMatcherConfig_delete(swig_self_);
  }

  explicit EmbeddingMatcherConfig(SwigObj_inworld_EmbeddingMatcherConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  EmbeddingMatcherConfig& operator=(EmbeddingMatcherConfig const&) = delete;
  EmbeddingMatcherConfig(EmbeddingMatcherConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  EmbeddingMatcherConfig& operator=(EmbeddingMatcherConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_EmbeddingMatcherConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_EmbeddingMatcherConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_EmbeddingMatcherConfig* swig_self_;
  bool swig_owns_self_;
};

class LlmMatcherConfig {
public:
  void generation_config(TextGenerationConfig * generation_config);
  TextGenerationConfig * generation_config() const;
  void prompt_template(std::string const& prompt_template);
  std::string prompt_template() const;
  void embedding_similarity_threshold(optional_float * embedding_similarity_threshold);
  optional_float * embedding_similarity_threshold() const;
  void max_embedding_matches_for_llm(optional_int * max_embedding_matches_for_llm);
  optional_int * max_embedding_matches_for_llm() const;
  LlmMatcherConfig();
  LlmMatcherConfig(LlmMatcherConfig const & other);
  ~LlmMatcherConfig() {
    if (swig_owns_self_)
      inworld_LlmMatcherConfig_delete(swig_self_);
  }

  explicit LlmMatcherConfig(SwigObj_inworld_LlmMatcherConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LlmMatcherConfig& operator=(LlmMatcherConfig const&) = delete;
  LlmMatcherConfig(LlmMatcherConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LlmMatcherConfig& operator=(LlmMatcherConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LlmMatcherConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LlmMatcherConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LlmMatcherConfig* swig_self_;
  bool swig_owns_self_;
};

class IntentMatcherConfig {
public:
  void embedding(optional_EmbeddingMatcherConfig * embedding);
  optional_EmbeddingMatcherConfig * embedding() const;
  void llm(optional_LlmMatcherConfig * llm);
  optional_LlmMatcherConfig * llm() const;
  void top_n_intents(int top_n_intents);
  int top_n_intents() const;
  IntentMatcherConfig();
  IntentMatcherConfig(IntentMatcherConfig const & other);
  ~IntentMatcherConfig() {
    if (swig_owns_self_)
      inworld_IntentMatcherConfig_delete(swig_self_);
  }

  explicit IntentMatcherConfig(SwigObj_inworld_IntentMatcherConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  IntentMatcherConfig& operator=(IntentMatcherConfig const&) = delete;
  IntentMatcherConfig(IntentMatcherConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  IntentMatcherConfig& operator=(IntentMatcherConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_IntentMatcherConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_IntentMatcherConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_IntentMatcherConfig* swig_self_;
  bool swig_owns_self_;
};

class IntentMatcherInterface {
public:
  static IntentMatcherInterface null() { return IntentMatcherInterface{(SwigObj_inworld_IntentMatcherInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~IntentMatcherInterface() {
    if (swig_owns_self_)
      inworld_IntentMatcherInterface_delete(swig_self_);
  }
  bool is_valid() const;
  StatusOr_vector_IntentMatch MatchIntents(std::string const& input) const;

  explicit IntentMatcherInterface(SwigObj_inworld_IntentMatcherInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  IntentMatcherInterface(IntentMatcherInterface const&) = delete;
  IntentMatcherInterface& operator=(IntentMatcherInterface const&) = delete;
  IntentMatcherInterface(IntentMatcherInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  IntentMatcherInterface& operator=(IntentMatcherInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_IntentMatcherInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_IntentMatcherInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_IntentMatcherInterface* swig_self_;
  bool swig_owns_self_;
};

class IntentMatcherCreationConfig {
public:
  void matcher_config(IntentMatcherConfig * matcher_config);
  IntentMatcherConfig * matcher_config() const;
  void compiled_intents(vector_CompiledIntent * compiled_intents);
  vector_CompiledIntent * compiled_intents() const;
  IntentMatcherCreationConfig();
  IntentMatcherCreationConfig(IntentMatcherCreationConfig const & other);
  ~IntentMatcherCreationConfig() {
    if (swig_owns_self_)
      inworld_IntentMatcherCreationConfig_delete(swig_self_);
  }

  explicit IntentMatcherCreationConfig(SwigObj_inworld_IntentMatcherCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  IntentMatcherCreationConfig& operator=(IntentMatcherCreationConfig const&) = delete;
  IntentMatcherCreationConfig(IntentMatcherCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  IntentMatcherCreationConfig& operator=(IntentMatcherCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_IntentMatcherCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_IntentMatcherCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_IntentMatcherCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class IntentMatcherFactory {
public:
  virtual ~IntentMatcherFactory() {
    if (swig_owns_self_)
      inworld_IntentMatcherFactory_delete(swig_self_);
  }
  StatusOr_IntentMatcherInterface CreateIntentMatcher(TextEmbedderInterface const& embedder, LLMInterface const& arg3, IntentMatcherCreationConfig const & arg4) const;
  StatusOr_IntentMatcherInterface CreateIntentMatcher(TextEmbedderInterface const& embedder, IntentMatcherCreationConfig const & arg3) const;
  StatusOr_IntentMatcherInterface CreateIntentMatcher(LLMInterface const& llm_client, IntentMatcherCreationConfig const & arg3) const;
  IntentMatcherFactory();
  IntentMatcherFactory(IntentMatcherFactory const & other);

  explicit IntentMatcherFactory(SwigObj_inworld_IntentMatcherFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  IntentMatcherFactory& operator=(IntentMatcherFactory const&) = delete;
  IntentMatcherFactory(IntentMatcherFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  IntentMatcherFactory& operator=(IntentMatcherFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_IntentMatcherFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_IntentMatcherFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_IntentMatcherFactory* swig_self_;
  bool swig_owns_self_;
};

class KeywordGroup {
public:
  void name(std::string const& name);
  std::string name() const;
  void keywords(vector_string * keywords);
  vector_string * keywords() const;
  KeywordGroup();
  KeywordGroup(KeywordGroup const & other);
  ~KeywordGroup() {
    if (swig_owns_self_)
      inworld_KeywordGroup_delete(swig_self_);
  }

  explicit KeywordGroup(SwigObj_inworld_KeywordGroup* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KeywordGroup& operator=(KeywordGroup const&) = delete;
  KeywordGroup(KeywordGroup&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KeywordGroup& operator=(KeywordGroup&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KeywordGroup_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KeywordGroup* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KeywordGroup* swig_self_;
  bool swig_owns_self_;
};

class KeywordMatch {
public:
  void group_name(std::string const& group_name);
  std::string group_name() const;
  void keyword(std::string const& keyword);
  std::string keyword() const;
  KeywordMatch();
  KeywordMatch(KeywordMatch const & other);
  ~KeywordMatch() {
    if (swig_owns_self_)
      inworld_KeywordMatch_delete(swig_self_);
  }

  explicit KeywordMatch(SwigObj_inworld_KeywordMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KeywordMatch& operator=(KeywordMatch const&) = delete;
  KeywordMatch(KeywordMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KeywordMatch& operator=(KeywordMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KeywordMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KeywordMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KeywordMatch* swig_self_;
  bool swig_owns_self_;
};

class KeywordMatcherResponse {
public:
  void matches(vector_KeywordMatch * matches);
  vector_KeywordMatch * matches() const;
  bool HasMatches() const;
  KeywordMatcherResponse();
  KeywordMatcherResponse(KeywordMatcherResponse const & other);
  ~KeywordMatcherResponse() {
    if (swig_owns_self_)
      inworld_KeywordMatcherResponse_delete(swig_self_);
  }

  explicit KeywordMatcherResponse(SwigObj_inworld_KeywordMatcherResponse* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KeywordMatcherResponse& operator=(KeywordMatcherResponse const&) = delete;
  KeywordMatcherResponse(KeywordMatcherResponse&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KeywordMatcherResponse& operator=(KeywordMatcherResponse&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KeywordMatcherResponse_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KeywordMatcherResponse* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KeywordMatcherResponse* swig_self_;
  bool swig_owns_self_;
};

class KeywordMatcherInterface {
public:
  static KeywordMatcherInterface null() { return KeywordMatcherInterface{(SwigObj_inworld_KeywordMatcherInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~KeywordMatcherInterface() {
    if (swig_owns_self_)
      inworld_KeywordMatcherInterface_delete(swig_self_);
  }
  bool is_valid() const;
  StatusOr_KeywordMatcherResponse MatchKeywords(std::string const& input) const;

  explicit KeywordMatcherInterface(SwigObj_inworld_KeywordMatcherInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KeywordMatcherInterface(KeywordMatcherInterface const&) = delete;
  KeywordMatcherInterface& operator=(KeywordMatcherInterface const&) = delete;
  KeywordMatcherInterface(KeywordMatcherInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KeywordMatcherInterface& operator=(KeywordMatcherInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KeywordMatcherInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KeywordMatcherInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KeywordMatcherInterface* swig_self_;
  bool swig_owns_self_;
};

class KeywordMatcherFactory {
public:
  virtual ~KeywordMatcherFactory() {
    if (swig_owns_self_)
      inworld_KeywordMatcherFactory_delete(swig_self_);
  }
  StatusOr_KeywordMatcherInterface CreateKeywordMatcher(vector_KeywordGroup const & keyword_groups) const;
  KeywordMatcherFactory();
  KeywordMatcherFactory(KeywordMatcherFactory const & other);

  explicit KeywordMatcherFactory(SwigObj_inworld_KeywordMatcherFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KeywordMatcherFactory& operator=(KeywordMatcherFactory const&) = delete;
  KeywordMatcherFactory(KeywordMatcherFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KeywordMatcherFactory& operator=(KeywordMatcherFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KeywordMatcherFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KeywordMatcherFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KeywordMatcherFactory* swig_self_;
  bool swig_owns_self_;
};

class DictionaryRule {
public:
  void name(std::string const& name);
  std::string name() const;
  void display_name(std::string const& display_name);
  std::string display_name() const;
  void synonyms(vector_string * synonyms);
  vector_string * synonyms() const;
  DictionaryRule();
  DictionaryRule(DictionaryRule const & other);
  ~DictionaryRule() {
    if (swig_owns_self_)
      inworld_DictionaryRule_delete(swig_self_);
  }

  explicit DictionaryRule(SwigObj_inworld_DictionaryRule* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  DictionaryRule& operator=(DictionaryRule const&) = delete;
  DictionaryRule(DictionaryRule&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  DictionaryRule& operator=(DictionaryRule&& obj) noexcept {
    if (swig_owns_self_)
      inworld_DictionaryRule_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_DictionaryRule* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_DictionaryRule* swig_self_;
  bool swig_owns_self_;
};

class Entity {
public:
  void name(std::string const& name);
  std::string name() const;
  void rules(vector_DictionaryRule * rules);
  vector_DictionaryRule * rules() const;
  Entity();
  Entity(Entity const & other);
  ~Entity() {
    if (swig_owns_self_)
      inworld_Entity_delete(swig_self_);
  }

  explicit Entity(SwigObj_inworld_Entity* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Entity& operator=(Entity const&) = delete;
  Entity(Entity&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Entity& operator=(Entity&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Entity_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Entity* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Entity* swig_self_;
  bool swig_owns_self_;
};

class EntityMatch {
public:
  void entity_name(std::string const& entity_name);
  std::string entity_name() const;
  void rule_name(std::string const& rule_name);
  std::string rule_name() const;
  void text(std::string const& text);
  std::string text() const;
  EntityMatch();
  EntityMatch(EntityMatch const & other);
  ~EntityMatch() {
    if (swig_owns_self_)
      inworld_EntityMatch_delete(swig_self_);
  }

  explicit EntityMatch(SwigObj_inworld_EntityMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  EntityMatch& operator=(EntityMatch const&) = delete;
  EntityMatch(EntityMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  EntityMatch& operator=(EntityMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_EntityMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_EntityMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_EntityMatch* swig_self_;
  bool swig_owns_self_;
};

class NERInterface {
public:
  static NERInterface null() { return NERInterface{(SwigObj_inworld_NERInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~NERInterface() {
    if (swig_owns_self_)
      inworld_NERInterface_delete(swig_self_);
  }
  virtual StatusOr_vector_EntityMatch ExtractEntities(std::string const& text) const;
  bool is_valid() const;

  explicit NERInterface(SwigObj_inworld_NERInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  NERInterface(NERInterface const&) = delete;
  NERInterface& operator=(NERInterface const&) = delete;
  NERInterface(NERInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  NERInterface& operator=(NERInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_NERInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_NERInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_NERInterface* swig_self_;
  bool swig_owns_self_;
};

class NERCreationConfig {
public:
  void entities(vector_Entity * entities);
  vector_Entity * entities() const;
  NERCreationConfig();
  NERCreationConfig(NERCreationConfig const & other);
  ~NERCreationConfig() {
    if (swig_owns_self_)
      inworld_NERCreationConfig_delete(swig_self_);
  }

  explicit NERCreationConfig(SwigObj_inworld_NERCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  NERCreationConfig& operator=(NERCreationConfig const&) = delete;
  NERCreationConfig(NERCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  NERCreationConfig& operator=(NERCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_NERCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_NERCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_NERCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class NERFactory {
public:
  static StatusOr_NERInterface inworld_inworld_NERFactory_CreateNER__SWIG(NERCreationConfig const & config);
  NERFactory();
  NERFactory(NERFactory const & other);
  ~NERFactory() {
    if (swig_owns_self_)
      inworld_NERFactory_delete(swig_self_);
  }

  explicit NERFactory(SwigObj_inworld_NERFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  NERFactory& operator=(NERFactory const&) = delete;
  NERFactory(NERFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  NERFactory& operator=(NERFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_NERFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_NERFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_NERFactory* swig_self_;
  bool swig_owns_self_;
};

class VectorClassThreshold {
public:
  VectorClassThreshold();
  VectorClassThreshold(VectorClassThreshold const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(ClassThreshold const & x);
  ClassThreshold get(int i);
  void set(int i, ClassThreshold const & arg3);
  ~VectorClassThreshold() {
    if (swig_owns_self_)
      inworld_VectorClassThreshold_delete(swig_self_);
  }

  explicit VectorClassThreshold(SwigObj_inworld_VectorClassThreshold* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  VectorClassThreshold& operator=(VectorClassThreshold const&) = delete;
  VectorClassThreshold(VectorClassThreshold&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  VectorClassThreshold& operator=(VectorClassThreshold&& obj) noexcept {
    if (swig_owns_self_)
      inworld_VectorClassThreshold_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_VectorClassThreshold* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_VectorClassThreshold* swig_self_;
  bool swig_owns_self_;
};

class TextClassifierResponseStatusOr {
public:
  TextClassifierResponseStatusOr();
  TextClassifierResponseStatusOr(TextClassifierResponse const & value);
  TextClassifierResponseStatusOr(Status const & status);
  bool ok() const;
  Status status() const;
  TextClassifierResponse value() const;
  TextClassifierResponseStatusOr(TextClassifierResponseStatusOr const & other);
  ~TextClassifierResponseStatusOr() {
    if (swig_owns_self_)
      inworld_TextClassifierResponseStatusOr_delete(swig_self_);
  }

  explicit TextClassifierResponseStatusOr(SwigObj_inworld_TextClassifierResponseStatusOr* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextClassifierResponseStatusOr& operator=(TextClassifierResponseStatusOr const&) = delete;
  TextClassifierResponseStatusOr(TextClassifierResponseStatusOr&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextClassifierResponseStatusOr& operator=(TextClassifierResponseStatusOr&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextClassifierResponseStatusOr_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextClassifierResponseStatusOr* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextClassifierResponseStatusOr* swig_self_;
  bool swig_owns_self_;
};

class ClassThreshold {
public:
  void class_label(std::string const& class_label);
  std::string class_label() const;
  void threshold(float threshold);
  float threshold() const;
  ClassThreshold();
  ClassThreshold(ClassThreshold const & other);
  ~ClassThreshold() {
    if (swig_owns_self_)
      inworld_ClassThreshold_delete(swig_self_);
  }

  explicit ClassThreshold(SwigObj_inworld_ClassThreshold* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ClassThreshold& operator=(ClassThreshold const&) = delete;
  ClassThreshold(ClassThreshold&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ClassThreshold& operator=(ClassThreshold&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ClassThreshold_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ClassThreshold* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ClassThreshold* swig_self_;
  bool swig_owns_self_;
};

class TextClassifierConfig {
public:
  void classes(VectorClassThreshold * classes);
  VectorClassThreshold * classes() const;
  TextClassifierConfig();
  TextClassifierConfig(TextClassifierConfig const & other);
  ~TextClassifierConfig() {
    if (swig_owns_self_)
      inworld_TextClassifierConfig_delete(swig_self_);
  }

  explicit TextClassifierConfig(SwigObj_inworld_TextClassifierConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextClassifierConfig& operator=(TextClassifierConfig const&) = delete;
  TextClassifierConfig(TextClassifierConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextClassifierConfig& operator=(TextClassifierConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextClassifierConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextClassifierConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextClassifierConfig* swig_self_;
  bool swig_owns_self_;
};

class TextClassifierResponse {
public:
  void classes(vector_string * classes);
  vector_string * classes() const;
  bool HasResults() const;
  TextClassifierResponse();
  TextClassifierResponse(TextClassifierResponse const & other);
  ~TextClassifierResponse() {
    if (swig_owns_self_)
      inworld_TextClassifierResponse_delete(swig_self_);
  }

  explicit TextClassifierResponse(SwigObj_inworld_TextClassifierResponse* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextClassifierResponse& operator=(TextClassifierResponse const&) = delete;
  TextClassifierResponse(TextClassifierResponse&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextClassifierResponse& operator=(TextClassifierResponse&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextClassifierResponse_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextClassifierResponse* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextClassifierResponse* swig_self_;
  bool swig_owns_self_;
};

class TextClassifierInterface {
public:
  virtual ~TextClassifierInterface() {
    if (swig_owns_self_)
      inworld_TextClassifierInterface_delete(swig_self_);
  }
  TextClassifierResponseStatusOr ClassifyText(std::string const& input) const;
  TextClassifierResponseStatusOr ClassifyText(std::string const& input, TextClassifierConfig const & arg3) const;

  explicit TextClassifierInterface(SwigObj_inworld_TextClassifierInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextClassifierInterface(TextClassifierInterface const&) = delete;
  TextClassifierInterface& operator=(TextClassifierInterface const&) = delete;
  TextClassifierInterface(TextClassifierInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextClassifierInterface& operator=(TextClassifierInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextClassifierInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextClassifierInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextClassifierInterface* swig_self_;
  bool swig_owns_self_;
};

class TextClassifierInterfaceSharedPtrStatusOr {
public:
  TextClassifierInterfaceSharedPtrStatusOr();
  TextClassifierInterfaceSharedPtrStatusOr(TextClassifierInterface const& value);
  TextClassifierInterfaceSharedPtrStatusOr(Status const & status);
  bool ok() const;
  Status status() const;
  TextClassifierInterface value() const;
  TextClassifierInterfaceSharedPtrStatusOr(TextClassifierInterfaceSharedPtrStatusOr const & other);
  ~TextClassifierInterfaceSharedPtrStatusOr() {
    if (swig_owns_self_)
      inworld_TextClassifierInterfaceSharedPtrStatusOr_delete(swig_self_);
  }

  explicit TextClassifierInterfaceSharedPtrStatusOr(SwigObj_inworld_TextClassifierInterfaceSharedPtrStatusOr* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextClassifierInterfaceSharedPtrStatusOr& operator=(TextClassifierInterfaceSharedPtrStatusOr const&) = delete;
  TextClassifierInterfaceSharedPtrStatusOr(TextClassifierInterfaceSharedPtrStatusOr&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextClassifierInterfaceSharedPtrStatusOr& operator=(TextClassifierInterfaceSharedPtrStatusOr&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextClassifierInterfaceSharedPtrStatusOr_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextClassifierInterfaceSharedPtrStatusOr* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextClassifierInterfaceSharedPtrStatusOr* swig_self_;
  bool swig_owns_self_;
};

class TextClassifierCreationConfig {
public:
  void model_weights_path(std::string const& model_weights_path);
  std::string model_weights_path() const;
  void supported_classes(vector_string * supported_classes);
  vector_string * supported_classes() const;
  TextClassifierCreationConfig();
  TextClassifierCreationConfig(TextClassifierCreationConfig const & other);
  ~TextClassifierCreationConfig() {
    if (swig_owns_self_)
      inworld_TextClassifierCreationConfig_delete(swig_self_);
  }

  explicit TextClassifierCreationConfig(SwigObj_inworld_TextClassifierCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextClassifierCreationConfig& operator=(TextClassifierCreationConfig const&) = delete;
  TextClassifierCreationConfig(TextClassifierCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextClassifierCreationConfig& operator=(TextClassifierCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextClassifierCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextClassifierCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextClassifierCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class TextClassifierFactory {
public:
  virtual ~TextClassifierFactory() {
    if (swig_owns_self_)
      inworld_TextClassifierFactory_delete(swig_self_);
  }
  TextClassifierInterfaceSharedPtrStatusOr CreateTextClassifier(TextEmbedderInterface const& embedder, TextClassifierCreationConfig const & arg3) const;
  TextClassifierFactory();
  TextClassifierFactory(TextClassifierFactory const & other);

  explicit TextClassifierFactory(SwigObj_inworld_TextClassifierFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextClassifierFactory& operator=(TextClassifierFactory const&) = delete;
  TextClassifierFactory(TextClassifierFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextClassifierFactory& operator=(TextClassifierFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextClassifierFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextClassifierFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextClassifierFactory* swig_self_;
  bool swig_owns_self_;
};

class TopicThreshold {
public:
  void topic_name(TopicName topic_name);
  TopicName topic_name() const;
  void threshold(float threshold);
  float threshold() const;
  TopicThreshold();
  TopicThreshold(TopicThreshold const & other);
  ~TopicThreshold() {
    if (swig_owns_self_)
      inworld_TopicThreshold_delete(swig_self_);
  }

  explicit TopicThreshold(SwigObj_inworld_TopicThreshold* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TopicThreshold& operator=(TopicThreshold const&) = delete;
  TopicThreshold(TopicThreshold&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TopicThreshold& operator=(TopicThreshold&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TopicThreshold_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TopicThreshold* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TopicThreshold* swig_self_;
  bool swig_owns_self_;
};

class SafetyConfig {
public:
  void forbidden_topics(vector_TopicThreshold * forbidden_topics);
  vector_TopicThreshold * forbidden_topics() const;
  SafetyConfig();
  SafetyConfig(SafetyConfig const & other);
  ~SafetyConfig() {
    if (swig_owns_self_)
      inworld_SafetyConfig_delete(swig_self_);
  }

  explicit SafetyConfig(SwigObj_inworld_SafetyConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SafetyConfig& operator=(SafetyConfig const&) = delete;
  SafetyConfig(SafetyConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SafetyConfig& operator=(SafetyConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SafetyConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SafetyConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SafetyConfig* swig_self_;
  bool swig_owns_self_;
};

class DetectedTopic {
public:
  void topic_name(TopicName topic_name);
  TopicName topic_name() const;
  void confidence(float confidence);
  float confidence() const;
  DetectedTopic();
  DetectedTopic(DetectedTopic const & other);
  ~DetectedTopic() {
    if (swig_owns_self_)
      inworld_DetectedTopic_delete(swig_self_);
  }

  explicit DetectedTopic(SwigObj_inworld_DetectedTopic* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  DetectedTopic& operator=(DetectedTopic const&) = delete;
  DetectedTopic(DetectedTopic&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  DetectedTopic& operator=(DetectedTopic&& obj) noexcept {
    if (swig_owns_self_)
      inworld_DetectedTopic_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_DetectedTopic* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_DetectedTopic* swig_self_;
  bool swig_owns_self_;
};

class CheckSafetyResponse {
public:
  void is_safe(bool is_safe);
  bool is_safe() const;
  void detected_topics(vector_DetectedTopic * detected_topics);
  vector_DetectedTopic * detected_topics() const;
  CheckSafetyResponse();
  CheckSafetyResponse(CheckSafetyResponse const & other);
  ~CheckSafetyResponse() {
    if (swig_owns_self_)
      inworld_CheckSafetyResponse_delete(swig_self_);
  }

  explicit CheckSafetyResponse(SwigObj_inworld_CheckSafetyResponse* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CheckSafetyResponse& operator=(CheckSafetyResponse const&) = delete;
  CheckSafetyResponse(CheckSafetyResponse&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CheckSafetyResponse& operator=(CheckSafetyResponse&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CheckSafetyResponse_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CheckSafetyResponse* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CheckSafetyResponse* swig_self_;
  bool swig_owns_self_;
};

class SafetyCheckerInterface {
public:
  static SafetyCheckerInterface null() { return SafetyCheckerInterface{(SwigObj_inworld_SafetyCheckerInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~SafetyCheckerInterface() {
    if (swig_owns_self_)
      inworld_SafetyCheckerInterface_delete(swig_self_);
  }
  bool is_valid() const;
  StatusOr_CheckSafetyResponse CheckSafety(std::string const& input) const;
  StatusOr_CheckSafetyResponse CheckSafety(std::string const& input, SafetyConfig const & arg3) const;

  explicit SafetyCheckerInterface(SwigObj_inworld_SafetyCheckerInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SafetyCheckerInterface(SafetyCheckerInterface const&) = delete;
  SafetyCheckerInterface& operator=(SafetyCheckerInterface const&) = delete;
  SafetyCheckerInterface(SafetyCheckerInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SafetyCheckerInterface& operator=(SafetyCheckerInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SafetyCheckerInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SafetyCheckerInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SafetyCheckerInterface* swig_self_;
  bool swig_owns_self_;
};

class SafetyCheckerCreationConfig {
public:
  void model_weights_path(std::string const& model_weights_path);
  std::string model_weights_path() const;
  SafetyCheckerCreationConfig();
  SafetyCheckerCreationConfig(SafetyCheckerCreationConfig const & other);
  ~SafetyCheckerCreationConfig() {
    if (swig_owns_self_)
      inworld_SafetyCheckerCreationConfig_delete(swig_self_);
  }

  explicit SafetyCheckerCreationConfig(SwigObj_inworld_SafetyCheckerCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SafetyCheckerCreationConfig& operator=(SafetyCheckerCreationConfig const&) = delete;
  SafetyCheckerCreationConfig(SafetyCheckerCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SafetyCheckerCreationConfig& operator=(SafetyCheckerCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SafetyCheckerCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SafetyCheckerCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SafetyCheckerCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class SafetyCheckerFactory {
public:
  virtual ~SafetyCheckerFactory() {
    if (swig_owns_self_)
      inworld_SafetyCheckerFactory_delete(swig_self_);
  }
  StatusOr_SafetyCheckerInterface CreateSafetyChecker(TextEmbedderInterface const& embedder, SafetyCheckerCreationConfig const & arg3) const;
  SafetyCheckerFactory();
  SafetyCheckerFactory(SafetyCheckerFactory const & other);

  explicit SafetyCheckerFactory(SwigObj_inworld_SafetyCheckerFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SafetyCheckerFactory& operator=(SafetyCheckerFactory const&) = delete;
  SafetyCheckerFactory(SafetyCheckerFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SafetyCheckerFactory& operator=(SafetyCheckerFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SafetyCheckerFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SafetyCheckerFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SafetyCheckerFactory* swig_self_;
  bool swig_owns_self_;
};

class EmojiRemover : public InputStream_string {
public:
  static EmojiRemover null() { return EmojiRemover{(SwigObj_inworld_EmojiRemover*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static StatusOr_EmojiRemover Create(InputStream_string const& input_stream);
  ~EmojiRemover() {
    if (swig_owns_self_) {
      inworld_EmojiRemover_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;

  explicit EmojiRemover(SwigObj_inworld_EmojiRemover* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  EmojiRemover(EmojiRemover const&) = delete;
  EmojiRemover& operator=(EmojiRemover const&) = delete;
  EmojiRemover(EmojiRemover&& obj) = default;
  EmojiRemover& operator=(EmojiRemover&& obj) = default;
  SwigObj_inworld_EmojiRemover* swig_self() const noexcept { return (SwigObj_inworld_EmojiRemover*)InputStream_string::swig_self(); }
};

class SentenceStreamCreationConfig {
public:
  void min_chunk_length(optional_int * min_chunk_length);
  optional_int * min_chunk_length() const;
  SentenceStreamCreationConfig();
  SentenceStreamCreationConfig(SentenceStreamCreationConfig const & other);
  ~SentenceStreamCreationConfig() {
    if (swig_owns_self_)
      inworld_SentenceStreamCreationConfig_delete(swig_self_);
  }

  explicit SentenceStreamCreationConfig(SwigObj_inworld_SentenceStreamCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SentenceStreamCreationConfig& operator=(SentenceStreamCreationConfig const&) = delete;
  SentenceStreamCreationConfig(SentenceStreamCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SentenceStreamCreationConfig& operator=(SentenceStreamCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SentenceStreamCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SentenceStreamCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SentenceStreamCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class SentenceStream : public InputStream_string {
public:
  static SentenceStream null() { return SentenceStream{(SwigObj_inworld_SentenceStream*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static StatusOr_SentenceStream Create(InputStream_string const& llm_stream);
  static StatusOr_SentenceStream Create(InputStream_string const& llm_stream, SentenceStreamCreationConfig const & arg2);
  ~SentenceStream() {
    if (swig_owns_self_) {
      inworld_SentenceStream_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;

  explicit SentenceStream(SwigObj_inworld_SentenceStream* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  SentenceStream(SentenceStream const&) = delete;
  SentenceStream& operator=(SentenceStream const&) = delete;
  SentenceStream(SentenceStream&& obj) = default;
  SentenceStream& operator=(SentenceStream&& obj) = default;
  SwigObj_inworld_SentenceStream* swig_self() const noexcept { return (SwigObj_inworld_SentenceStream*)InputStream_string::swig_self(); }
};

class SubstringRemover : public InputStream_string {
public:
  static SubstringRemover null() { return SubstringRemover{(SwigObj_inworld_SubstringRemover*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static StatusOr_SubstringRemover Create(InputStream_string const& input_stream, vector_string const & arg2);
  ~SubstringRemover() {
    if (swig_owns_self_) {
      inworld_SubstringRemover_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;

  explicit SubstringRemover(SwigObj_inworld_SubstringRemover* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  SubstringRemover(SubstringRemover const&) = delete;
  SubstringRemover& operator=(SubstringRemover const&) = delete;
  SubstringRemover(SubstringRemover&& obj) = default;
  SubstringRemover& operator=(SubstringRemover&& obj) = default;
  SwigObj_inworld_SubstringRemover* swig_self() const noexcept { return (SwigObj_inworld_SubstringRemover*)InputStream_string::swig_self(); }
};

class TextInBracketsRemover : public InputStream_string {
public:
  static TextInBracketsRemover null() { return TextInBracketsRemover{(SwigObj_inworld_TextInBracketsRemover*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static StatusOr_TextInBracketsRemover Create(InputStream_string const& input_stream);
  ~TextInBracketsRemover() {
    if (swig_owns_self_) {
      inworld_TextInBracketsRemover_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;

  explicit TextInBracketsRemover(SwigObj_inworld_TextInBracketsRemover* swig_self, bool swig_owns_self = true) noexcept : InputStream_string{(SwigObj_inworld_InputStream_string*)swig_self, swig_owns_self} {}
  TextInBracketsRemover(TextInBracketsRemover const&) = delete;
  TextInBracketsRemover& operator=(TextInBracketsRemover const&) = delete;
  TextInBracketsRemover(TextInBracketsRemover&& obj) = default;
  TextInBracketsRemover& operator=(TextInBracketsRemover&& obj) = default;
  SwigObj_inworld_TextInBracketsRemover* swig_self() const noexcept { return (SwigObj_inworld_TextInBracketsRemover*)InputStream_string::swig_self(); }
};

class optional_LocalSTTConfig {
public:
  optional_LocalSTTConfig();
  optional_LocalSTTConfig(LocalSTTConfig const & value);
  optional_LocalSTTConfig(optional_LocalSTTConfig const & other);
  ~optional_LocalSTTConfig() {
    if (swig_owns_self_)
      inworld_optional_LocalSTTConfig_delete(swig_self_);
  }
  bool has_value() const;
  LocalSTTConfig value();
  LocalSTTConfig value() const;
  LocalSTTConfig value_or(LocalSTTConfig const & default_value) const;
  void reset();
  LocalSTTConfig operator *();
  LocalSTTConfig operator *() const;
  LocalSTTConfig get_value();
  void set_value(LocalSTTConfig & t);

  explicit optional_LocalSTTConfig(SwigObj_inworld_optional_LocalSTTConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_LocalSTTConfig& operator=(optional_LocalSTTConfig const&) = delete;
  optional_LocalSTTConfig(optional_LocalSTTConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_LocalSTTConfig& operator=(optional_LocalSTTConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_LocalSTTConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_LocalSTTConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_LocalSTTConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_RemoteSTTConfig {
public:
  optional_RemoteSTTConfig();
  optional_RemoteSTTConfig(RemoteSTTConfig const & value);
  optional_RemoteSTTConfig(optional_RemoteSTTConfig const & other);
  ~optional_RemoteSTTConfig() {
    if (swig_owns_self_)
      inworld_optional_RemoteSTTConfig_delete(swig_self_);
  }
  bool has_value() const;
  RemoteSTTConfig value();
  RemoteSTTConfig value() const;
  RemoteSTTConfig value_or(RemoteSTTConfig const & default_value) const;
  void reset();
  RemoteSTTConfig operator *();
  RemoteSTTConfig operator *() const;
  RemoteSTTConfig get_value();
  void set_value(RemoteSTTConfig & t);

  explicit optional_RemoteSTTConfig(SwigObj_inworld_optional_RemoteSTTConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_RemoteSTTConfig& operator=(optional_RemoteSTTConfig const&) = delete;
  optional_RemoteSTTConfig(optional_RemoteSTTConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_RemoteSTTConfig& operator=(optional_RemoteSTTConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_RemoteSTTConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_RemoteSTTConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_RemoteSTTConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_Language {
public:
  optional_Language();
  optional_Language(Language const & value);
  optional_Language(optional_Language const & other);
  ~optional_Language() {
    if (swig_owns_self_)
      inworld_optional_Language_delete(swig_self_);
  }
  bool has_value() const;
  Language value();
  Language value() const;
  Language value_or(Language const & default_value) const;
  void reset();
  Language operator *();
  Language operator *() const;
  Language get_value();
  void set_value(Language & t);

  explicit optional_Language(SwigObj_inworld_optional_Language* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_Language& operator=(optional_Language const&) = delete;
  optional_Language(optional_Language&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_Language& operator=(optional_Language&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_Language_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_Language* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_Language* swig_self_;
  bool swig_owns_self_;
};

class LocalSTTConfig {
public:
  void model_path(std::string const& model_path);
  std::string model_path() const;
  void device(Device * device);
  Device * device() const;
  void default_config(SpeechRecognitionConfig * default_config);
  SpeechRecognitionConfig * default_config() const;
  LocalSTTConfig();
  LocalSTTConfig(LocalSTTConfig const & other);
  ~LocalSTTConfig() {
    if (swig_owns_self_)
      inworld_LocalSTTConfig_delete(swig_self_);
  }

  explicit LocalSTTConfig(SwigObj_inworld_LocalSTTConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LocalSTTConfig& operator=(LocalSTTConfig const&) = delete;
  LocalSTTConfig(LocalSTTConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LocalSTTConfig& operator=(LocalSTTConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LocalSTTConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LocalSTTConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LocalSTTConfig* swig_self_;
  bool swig_owns_self_;
};

class RemoteSTTConfig {
public:
  void api_key(std::string const& api_key);
  std::string api_key() const;
  void default_config(SpeechRecognitionConfig * default_config);
  SpeechRecognitionConfig * default_config() const;
  RemoteSTTConfig();
  RemoteSTTConfig(RemoteSTTConfig const & other);
  ~RemoteSTTConfig() {
    if (swig_owns_self_)
      inworld_RemoteSTTConfig_delete(swig_self_);
  }

  explicit RemoteSTTConfig(SwigObj_inworld_RemoteSTTConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  RemoteSTTConfig& operator=(RemoteSTTConfig const&) = delete;
  RemoteSTTConfig(RemoteSTTConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  RemoteSTTConfig& operator=(RemoteSTTConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_RemoteSTTConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_RemoteSTTConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_RemoteSTTConfig* swig_self_;
  bool swig_owns_self_;
};

class STTCreationConfig {
public:
  bool has_local_config();
  bool has_remote_config();
  optional_LocalSTTConfig get_local_config();
  optional_RemoteSTTConfig get_remote_config();
  void set_local_config(LocalSTTConfig const & config);
  void set_remote_config(RemoteSTTConfig const & config);
  STTCreationConfig();
  STTCreationConfig(STTCreationConfig const & other);
  ~STTCreationConfig() {
    if (swig_owns_self_)
      inworld_STTCreationConfig_delete(swig_self_);
  }

  explicit STTCreationConfig(SwigObj_inworld_STTCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  STTCreationConfig& operator=(STTCreationConfig const&) = delete;
  STTCreationConfig(STTCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  STTCreationConfig& operator=(STTCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_STTCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_STTCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_STTCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class STTFactory {
public:
  virtual ~STTFactory() {
    if (swig_owns_self_)
      inworld_STTFactory_delete(swig_self_);
  }
  StatusOr_STTInterface CreateSTT(LocalSTTConfig const & config) const;
  StatusOr_STTInterface CreateSTT(RemoteSTTConfig const & config) const;
  STTFactory();
  STTFactory(STTFactory const & other);

  explicit STTFactory(SwigObj_inworld_STTFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  STTFactory& operator=(STTFactory const&) = delete;
  STTFactory(STTFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  STTFactory& operator=(STTFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_STTFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_STTFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_STTFactory* swig_self_;
  bool swig_owns_self_;
};

class StreamSpeechRecognitionConfig {
public:
  void speech_config(SpeechRecognitionConfig * speech_config);
  SpeechRecognitionConfig * speech_config() const;
  void silence_threshold_ms(int silence_threshold_ms);
  int silence_threshold_ms() const;
  StreamSpeechRecognitionConfig();
  StreamSpeechRecognitionConfig(StreamSpeechRecognitionConfig const & other);
  ~StreamSpeechRecognitionConfig() {
    if (swig_owns_self_)
      inworld_StreamSpeechRecognitionConfig_delete(swig_self_);
  }

  explicit StreamSpeechRecognitionConfig(SwigObj_inworld_StreamSpeechRecognitionConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StreamSpeechRecognitionConfig& operator=(StreamSpeechRecognitionConfig const&) = delete;
  StreamSpeechRecognitionConfig(StreamSpeechRecognitionConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StreamSpeechRecognitionConfig& operator=(StreamSpeechRecognitionConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StreamSpeechRecognitionConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StreamSpeechRecognitionConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StreamSpeechRecognitionConfig* swig_self_;
  bool swig_owns_self_;
};

class StreamingSTTInterface : public ModelInterface {
public:
  static StreamingSTTInterface null() { return StreamingSTTInterface{(SwigObj_inworld_StreamingSTTInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~StreamingSTTInterface() {
    if (swig_owns_self_) {
      inworld_StreamingSTTInterface_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;

  explicit StreamingSTTInterface(SwigObj_inworld_StreamingSTTInterface* swig_self, bool swig_owns_self = true) noexcept : ModelInterface{(SwigObj_inworld_ModelInterface*)swig_self, swig_owns_self} {}
  StreamingSTTInterface(StreamingSTTInterface const&) = delete;
  StreamingSTTInterface& operator=(StreamingSTTInterface const&) = delete;
  StreamingSTTInterface(StreamingSTTInterface&& obj) = default;
  StreamingSTTInterface& operator=(StreamingSTTInterface&& obj) = default;
  SwigObj_inworld_StreamingSTTInterface* swig_self() const noexcept { return (SwigObj_inworld_StreamingSTTInterface*)ModelInterface::swig_self(); }
};

class optional_LocalStreamingSTTConfig {
public:
  optional_LocalStreamingSTTConfig();
  optional_LocalStreamingSTTConfig(LocalStreamingSTTConfig const & value);
  optional_LocalStreamingSTTConfig(optional_LocalStreamingSTTConfig const & other);
  ~optional_LocalStreamingSTTConfig() {
    if (swig_owns_self_)
      inworld_optional_LocalStreamingSTTConfig_delete(swig_self_);
  }
  bool has_value() const;
  LocalStreamingSTTConfig value();
  LocalStreamingSTTConfig value() const;
  LocalStreamingSTTConfig value_or(LocalStreamingSTTConfig const & default_value) const;
  void reset();
  LocalStreamingSTTConfig operator *();
  LocalStreamingSTTConfig operator *() const;
  LocalStreamingSTTConfig get_value();
  void set_value(LocalStreamingSTTConfig & t);

  explicit optional_LocalStreamingSTTConfig(SwigObj_inworld_optional_LocalStreamingSTTConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_LocalStreamingSTTConfig& operator=(optional_LocalStreamingSTTConfig const&) = delete;
  optional_LocalStreamingSTTConfig(optional_LocalStreamingSTTConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_LocalStreamingSTTConfig& operator=(optional_LocalStreamingSTTConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_LocalStreamingSTTConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_LocalStreamingSTTConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_LocalStreamingSTTConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_RemoteStreamingSTTConfig {
public:
  optional_RemoteStreamingSTTConfig();
  optional_RemoteStreamingSTTConfig(RemoteStreamingSTTConfig const & value);
  optional_RemoteStreamingSTTConfig(optional_RemoteStreamingSTTConfig const & other);
  ~optional_RemoteStreamingSTTConfig() {
    if (swig_owns_self_)
      inworld_optional_RemoteStreamingSTTConfig_delete(swig_self_);
  }
  bool has_value() const;
  RemoteStreamingSTTConfig value();
  RemoteStreamingSTTConfig value() const;
  RemoteStreamingSTTConfig value_or(RemoteStreamingSTTConfig const & default_value) const;
  void reset();
  RemoteStreamingSTTConfig operator *();
  RemoteStreamingSTTConfig operator *() const;
  RemoteStreamingSTTConfig get_value();
  void set_value(RemoteStreamingSTTConfig & t);

  explicit optional_RemoteStreamingSTTConfig(SwigObj_inworld_optional_RemoteStreamingSTTConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_RemoteStreamingSTTConfig& operator=(optional_RemoteStreamingSTTConfig const&) = delete;
  optional_RemoteStreamingSTTConfig(optional_RemoteStreamingSTTConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_RemoteStreamingSTTConfig& operator=(optional_RemoteStreamingSTTConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_RemoteStreamingSTTConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_RemoteStreamingSTTConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_RemoteStreamingSTTConfig* swig_self_;
  bool swig_owns_self_;
};

class LocalStreamingSTTConfig {
public:
  void stt_model_path(std::string const& stt_model_path);
  std::string stt_model_path() const;
  void vad_model_path(std::string const& vad_model_path);
  std::string vad_model_path() const;
  void stt_device(Device * stt_device);
  Device * stt_device() const;
  void vad_device(Device * vad_device);
  Device * vad_device() const;
  void default_config(StreamSpeechRecognitionConfig * default_config);
  StreamSpeechRecognitionConfig * default_config() const;
  LocalStreamingSTTConfig();
  LocalStreamingSTTConfig(LocalStreamingSTTConfig const & other);
  ~LocalStreamingSTTConfig() {
    if (swig_owns_self_)
      inworld_LocalStreamingSTTConfig_delete(swig_self_);
  }

  explicit LocalStreamingSTTConfig(SwigObj_inworld_LocalStreamingSTTConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LocalStreamingSTTConfig& operator=(LocalStreamingSTTConfig const&) = delete;
  LocalStreamingSTTConfig(LocalStreamingSTTConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LocalStreamingSTTConfig& operator=(LocalStreamingSTTConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LocalStreamingSTTConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LocalStreamingSTTConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LocalStreamingSTTConfig* swig_self_;
  bool swig_owns_self_;
};

class RemoteStreamingSTTConfig {
public:
  void api_key(std::string const& api_key);
  std::string api_key() const;
  void default_config(StreamSpeechRecognitionConfig * default_config);
  StreamSpeechRecognitionConfig * default_config() const;
  RemoteStreamingSTTConfig();
  RemoteStreamingSTTConfig(RemoteStreamingSTTConfig const & other);
  ~RemoteStreamingSTTConfig() {
    if (swig_owns_self_)
      inworld_RemoteStreamingSTTConfig_delete(swig_self_);
  }

  explicit RemoteStreamingSTTConfig(SwigObj_inworld_RemoteStreamingSTTConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  RemoteStreamingSTTConfig& operator=(RemoteStreamingSTTConfig const&) = delete;
  RemoteStreamingSTTConfig(RemoteStreamingSTTConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  RemoteStreamingSTTConfig& operator=(RemoteStreamingSTTConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_RemoteStreamingSTTConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_RemoteStreamingSTTConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_RemoteStreamingSTTConfig* swig_self_;
  bool swig_owns_self_;
};

class StreamingSTTCreationConfig {
public:
  bool has_local_config();
  bool has_remote_config();
  optional_LocalStreamingSTTConfig get_local_config();
  optional_RemoteStreamingSTTConfig get_remote_config();
  void set_local_config(LocalStreamingSTTConfig const & config);
  void set_remote_config(RemoteStreamingSTTConfig const & config);
  StreamingSTTCreationConfig();
  StreamingSTTCreationConfig(StreamingSTTCreationConfig const & other);
  ~StreamingSTTCreationConfig() {
    if (swig_owns_self_)
      inworld_StreamingSTTCreationConfig_delete(swig_self_);
  }

  explicit StreamingSTTCreationConfig(SwigObj_inworld_StreamingSTTCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StreamingSTTCreationConfig& operator=(StreamingSTTCreationConfig const&) = delete;
  StreamingSTTCreationConfig(StreamingSTTCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StreamingSTTCreationConfig& operator=(StreamingSTTCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StreamingSTTCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StreamingSTTCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StreamingSTTCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class StreamingSTTFactory {
public:
  virtual ~StreamingSTTFactory() {
    if (swig_owns_self_)
      inworld_StreamingSTTFactory_delete(swig_self_);
  }
  StreamingSTTFactory();
  StreamingSTTFactory(StreamingSTTFactory const & other);

  explicit StreamingSTTFactory(SwigObj_inworld_StreamingSTTFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StreamingSTTFactory& operator=(StreamingSTTFactory const&) = delete;
  StreamingSTTFactory(StreamingSTTFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StreamingSTTFactory& operator=(StreamingSTTFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StreamingSTTFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StreamingSTTFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StreamingSTTFactory* swig_self_;
  bool swig_owns_self_;
};

class optional_RemoteTTSConfig {
public:
  optional_RemoteTTSConfig();
  optional_RemoteTTSConfig(RemoteTTSConfig const & value);
  optional_RemoteTTSConfig(optional_RemoteTTSConfig const & other);
  ~optional_RemoteTTSConfig() {
    if (swig_owns_self_)
      inworld_optional_RemoteTTSConfig_delete(swig_self_);
  }
  bool has_value() const;
  RemoteTTSConfig value();
  RemoteTTSConfig value() const;
  RemoteTTSConfig value_or(RemoteTTSConfig const & default_value) const;
  void reset();
  RemoteTTSConfig operator *();
  RemoteTTSConfig operator *() const;
  RemoteTTSConfig get_value();
  void set_value(RemoteTTSConfig & t);

  explicit optional_RemoteTTSConfig(SwigObj_inworld_optional_RemoteTTSConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_RemoteTTSConfig& operator=(optional_RemoteTTSConfig const&) = delete;
  optional_RemoteTTSConfig(optional_RemoteTTSConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_RemoteTTSConfig& operator=(optional_RemoteTTSConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_RemoteTTSConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_RemoteTTSConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_RemoteTTSConfig* swig_self_;
  bool swig_owns_self_;
};

class LocalTTSConfig {
public:
  LocalTTSConfig();
  LocalTTSConfig(LocalTTSConfig const & other);
  ~LocalTTSConfig() {
    if (swig_owns_self_)
      inworld_LocalTTSConfig_delete(swig_self_);
  }

  explicit LocalTTSConfig(SwigObj_inworld_LocalTTSConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LocalTTSConfig& operator=(LocalTTSConfig const&) = delete;
  LocalTTSConfig(LocalTTSConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LocalTTSConfig& operator=(LocalTTSConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LocalTTSConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LocalTTSConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LocalTTSConfig* swig_self_;
  bool swig_owns_self_;
};

class RemoteTTSConfig {
public:
  void api_key(std::string const& api_key);
  std::string api_key() const;
  void synthesis_config(SpeechSynthesisConfig * synthesis_config);
  SpeechSynthesisConfig * synthesis_config() const;
  RemoteTTSConfig();
  RemoteTTSConfig(RemoteTTSConfig const & other);
  ~RemoteTTSConfig() {
    if (swig_owns_self_)
      inworld_RemoteTTSConfig_delete(swig_self_);
  }

  explicit RemoteTTSConfig(SwigObj_inworld_RemoteTTSConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  RemoteTTSConfig& operator=(RemoteTTSConfig const&) = delete;
  RemoteTTSConfig(RemoteTTSConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  RemoteTTSConfig& operator=(RemoteTTSConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_RemoteTTSConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_RemoteTTSConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_RemoteTTSConfig* swig_self_;
  bool swig_owns_self_;
};

class TTSCreationConfig {
public:
  bool has_remote_config();
  optional_RemoteTTSConfig get_remote_config();
  void set_remote_config(RemoteTTSConfig const & config);
  TTSCreationConfig();
  TTSCreationConfig(TTSCreationConfig const & other);
  ~TTSCreationConfig() {
    if (swig_owns_self_)
      inworld_TTSCreationConfig_delete(swig_self_);
  }

  explicit TTSCreationConfig(SwigObj_inworld_TTSCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TTSCreationConfig& operator=(TTSCreationConfig const&) = delete;
  TTSCreationConfig(TTSCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TTSCreationConfig& operator=(TTSCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TTSCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TTSCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TTSCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class TTSFactory {
public:
  virtual ~TTSFactory() {
    if (swig_owns_self_)
      inworld_TTSFactory_delete(swig_self_);
  }
  StatusOr_TTSInterface CreateTTS(RemoteTTSConfig const & config) const;
  TTSFactory();
  TTSFactory(TTSFactory const & other);

  explicit TTSFactory(SwigObj_inworld_TTSFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TTSFactory& operator=(TTSFactory const&) = delete;
  TTSFactory(TTSFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TTSFactory& operator=(TTSFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TTSFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TTSFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TTSFactory* swig_self_;
  bool swig_owns_self_;
};

class SilenceIntervals {
public:
  static SilenceIntervals null() { return SilenceIntervals{(SwigObj_inworld_SilenceIntervals*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  SilenceIntervals();
  SilenceIntervals(SilenceIntervals const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(IntPair const & x);
  IntPair get(int i);
  void set(int i, IntPair const & arg3);
  ~SilenceIntervals() {
    if (swig_owns_self_)
      inworld_SilenceIntervals_delete(swig_self_);
  }

  explicit SilenceIntervals(SwigObj_inworld_SilenceIntervals* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SilenceIntervals& operator=(SilenceIntervals const&) = delete;
  SilenceIntervals(SilenceIntervals&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SilenceIntervals& operator=(SilenceIntervals&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SilenceIntervals_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SilenceIntervals* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SilenceIntervals* swig_self_;
  bool swig_owns_self_;
};

class IntPair {
public:
  IntPair();
  IntPair(int first, int arg2);
  IntPair(IntPair const & other);
  void first(int first);
  int first() const;
  void second(int second);
  int second() const;
  ~IntPair() {
    if (swig_owns_self_)
      inworld_IntPair_delete(swig_self_);
  }

  explicit IntPair(SwigObj_inworld_IntPair* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  IntPair& operator=(IntPair const&) = delete;
  IntPair(IntPair&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  IntPair& operator=(IntPair&& obj) noexcept {
    if (swig_owns_self_)
      inworld_IntPair_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_IntPair* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_IntPair* swig_self_;
  bool swig_owns_self_;
};

class VoiceActivityDetectionConfig {
public:
  void speech_threshold(float speech_threshold);
  float speech_threshold() const;
  VoiceActivityDetectionConfig();
  VoiceActivityDetectionConfig(VoiceActivityDetectionConfig const & other);
  ~VoiceActivityDetectionConfig() {
    if (swig_owns_self_)
      inworld_VoiceActivityDetectionConfig_delete(swig_self_);
  }

  explicit VoiceActivityDetectionConfig(SwigObj_inworld_VoiceActivityDetectionConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  VoiceActivityDetectionConfig& operator=(VoiceActivityDetectionConfig const&) = delete;
  VoiceActivityDetectionConfig(VoiceActivityDetectionConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  VoiceActivityDetectionConfig& operator=(VoiceActivityDetectionConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_VoiceActivityDetectionConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_VoiceActivityDetectionConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_VoiceActivityDetectionConfig* swig_self_;
  bool swig_owns_self_;
};

class VADInterface : public ModelInterface {
public:
  static VADInterface null() { return VADInterface{(SwigObj_inworld_VADInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~VADInterface() {
    if (swig_owns_self_) {
      inworld_VADInterface_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;
  StatusOr_int DetectVoiceActivity(AudioChunk const & audio_chunk, VoiceActivityDetectionConfig const & arg3);
  StatusOr_int DetectVoiceActivity(AudioChunk const & audio_chunk);
  StatusOr_SilenceIntervals DetectSilence(vector_float const & audio_data, int arg3, VoiceActivityDetectionConfig const & arg4);
  StatusOr_SilenceIntervals DetectSilence(vector_float const & audio_data, int arg3);

  explicit VADInterface(SwigObj_inworld_VADInterface* swig_self, bool swig_owns_self = true) noexcept : ModelInterface{(SwigObj_inworld_ModelInterface*)swig_self, swig_owns_self} {}
  VADInterface(VADInterface const&) = delete;
  VADInterface& operator=(VADInterface const&) = delete;
  VADInterface(VADInterface&& obj) = default;
  VADInterface& operator=(VADInterface&& obj) = default;
  SwigObj_inworld_VADInterface* swig_self() const noexcept { return (SwigObj_inworld_VADInterface*)ModelInterface::swig_self(); }
};

class LocalVADConfig {
public:
  void model_path(std::string const& model_path);
  std::string model_path() const;
  void device(Device * device);
  Device * device() const;
  void default_config(VoiceActivityDetectionConfig * default_config);
  VoiceActivityDetectionConfig * default_config() const;
  LocalVADConfig();
  LocalVADConfig(LocalVADConfig const & other);
  ~LocalVADConfig() {
    if (swig_owns_self_)
      inworld_LocalVADConfig_delete(swig_self_);
  }

  explicit LocalVADConfig(SwigObj_inworld_LocalVADConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LocalVADConfig& operator=(LocalVADConfig const&) = delete;
  LocalVADConfig(LocalVADConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LocalVADConfig& operator=(LocalVADConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LocalVADConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LocalVADConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LocalVADConfig* swig_self_;
  bool swig_owns_self_;
};

class VADFactory {
public:
  virtual ~VADFactory() {
    if (swig_owns_self_)
      inworld_VADFactory_delete(swig_self_);
  }
  StatusOr_VADInterface CreateVAD(LocalVADConfig const & config) const;
  VADFactory();
  VADFactory(VADFactory const & other);

  explicit VADFactory(SwigObj_inworld_VADFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  VADFactory& operator=(VADFactory const&) = delete;
  VADFactory(VADFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  VADFactory& operator=(VADFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_VADFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_VADFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_VADFactory* swig_self_;
  bool swig_owns_self_;
};

class AcousticEchoCancellationConfig {
public:
  AcousticEchoCancellationConfig();
  AcousticEchoCancellationConfig(AcousticEchoCancellationConfig const & other);
  ~AcousticEchoCancellationConfig() {
    if (swig_owns_self_)
      inworld_AcousticEchoCancellationConfig_delete(swig_self_);
  }

  explicit AcousticEchoCancellationConfig(SwigObj_inworld_AcousticEchoCancellationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  AcousticEchoCancellationConfig& operator=(AcousticEchoCancellationConfig const&) = delete;
  AcousticEchoCancellationConfig(AcousticEchoCancellationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  AcousticEchoCancellationConfig& operator=(AcousticEchoCancellationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_AcousticEchoCancellationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_AcousticEchoCancellationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_AcousticEchoCancellationConfig* swig_self_;
  bool swig_owns_self_;
};

class AECFilterInterface : public ModelInterface {
public:
  static AECFilterInterface null() { return AECFilterInterface{(SwigObj_inworld_AECFilterInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~AECFilterInterface() {
    if (swig_owns_self_) {
      inworld_AECFilterInterface_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;
  StatusOr_AudioChunk FilterAudio(AudioChunk const & microphone_chunk, AudioChunk const & arg3);

  explicit AECFilterInterface(SwigObj_inworld_AECFilterInterface* swig_self, bool swig_owns_self = true) noexcept : ModelInterface{(SwigObj_inworld_ModelInterface*)swig_self, swig_owns_self} {}
  AECFilterInterface(AECFilterInterface const&) = delete;
  AECFilterInterface& operator=(AECFilterInterface const&) = delete;
  AECFilterInterface(AECFilterInterface&& obj) = default;
  AECFilterInterface& operator=(AECFilterInterface&& obj) = default;
  SwigObj_inworld_AECFilterInterface* swig_self() const noexcept { return (SwigObj_inworld_AECFilterInterface*)ModelInterface::swig_self(); }
};

class LocalAECFilterConfig {
public:
  void device(Device * device);
  Device * device() const;
  void default_config(AcousticEchoCancellationConfig * default_config);
  AcousticEchoCancellationConfig * default_config() const;
  LocalAECFilterConfig();
  LocalAECFilterConfig(LocalAECFilterConfig const & other);
  ~LocalAECFilterConfig() {
    if (swig_owns_self_)
      inworld_LocalAECFilterConfig_delete(swig_self_);
  }

  explicit LocalAECFilterConfig(SwigObj_inworld_LocalAECFilterConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LocalAECFilterConfig& operator=(LocalAECFilterConfig const&) = delete;
  LocalAECFilterConfig(LocalAECFilterConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LocalAECFilterConfig& operator=(LocalAECFilterConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LocalAECFilterConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LocalAECFilterConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LocalAECFilterConfig* swig_self_;
  bool swig_owns_self_;
};

class AECFilterFactory {
public:
  virtual ~AECFilterFactory() {
    if (swig_owns_self_)
      inworld_AECFilterFactory_delete(swig_self_);
  }
  StatusOr_AECFilterInterface CreateAECFilter(LocalAECFilterConfig const & config) const;
  AECFilterFactory();
  AECFilterFactory(AECFilterFactory const & other);

  explicit AECFilterFactory(SwigObj_inworld_AECFilterFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  AECFilterFactory& operator=(AECFilterFactory const&) = delete;
  AECFilterFactory(AECFilterFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  AECFilterFactory& operator=(AECFilterFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_AECFilterFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_AECFilterFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_AECFilterFactory* swig_self_;
  bool swig_owns_self_;
};

class NodeExecutionTelemetryContext {
public:
  static NodeExecutionTelemetryContext null() { return NodeExecutionTelemetryContext{(SwigObj_inworld_NodeExecutionTelemetryContext*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  std::string execution_id() const;
  bool is_valid() const;
  ~NodeExecutionTelemetryContext() {
    if (swig_owns_self_)
      inworld_NodeExecutionTelemetryContext_delete(swig_self_);
  }

  explicit NodeExecutionTelemetryContext(SwigObj_inworld_NodeExecutionTelemetryContext* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  NodeExecutionTelemetryContext(NodeExecutionTelemetryContext const&) = delete;
  NodeExecutionTelemetryContext& operator=(NodeExecutionTelemetryContext const&) = delete;
  NodeExecutionTelemetryContext(NodeExecutionTelemetryContext&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  NodeExecutionTelemetryContext& operator=(NodeExecutionTelemetryContext&& obj) noexcept {
    if (swig_owns_self_)
      inworld_NodeExecutionTelemetryContext_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_NodeExecutionTelemetryContext* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_NodeExecutionTelemetryContext* swig_self_;
  bool swig_owns_self_;
};

class CancellationContext {
public:
  static CancellationContext null() { return CancellationContext{(SwigObj_inworld_CancellationContext*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~CancellationContext() {
    if (swig_owns_self_)
      inworld_CancellationContext_delete(swig_self_);
  }
  bool IsCancelled() const;
  bool is_valid() const;

  explicit CancellationContext(SwigObj_inworld_CancellationContext* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CancellationContext(CancellationContext const&) = delete;
  CancellationContext& operator=(CancellationContext const&) = delete;
  CancellationContext(CancellationContext&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CancellationContext& operator=(CancellationContext&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CancellationContext_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CancellationContext* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CancellationContext* swig_self_;
  bool swig_owns_self_;
};

class ProcessContext {
public:
  ~ProcessContext() {
    if (swig_owns_self_)
      inworld_ProcessContext_delete(swig_self_);
  }
  ProcessContext(ProcessContext const & arg1);
  std::string GetVariant() const;
  std::string GetExecutionId() const;
  NodeExecutionConfig GetConfig() const;
  bool IsCancelled() const;
  CancellationContext GetCancellationContext() const;
  NodeExecutionTelemetryContext GetNodeExecutionTelemetryContext() const;
  StatusOr_SharedPtr_GoalAdvancementNode GetComponent_GoalAdvancementNode(std::string const& id) const;
  StatusOr_SharedPtr_IntentNode GetComponent_IntentNode(std::string const& id) const;
  StatusOr_SharedPtr_KeywordMatcherNode GetComponent_KeywordMatcherNode(std::string const& id) const;
  StatusOr_SharedPtr_KnowledgeNode GetComponent_KnowledgeNode(std::string const& id) const;
  StatusOr_SharedPtr_LLMChatNode GetComponent_LLMChatNode(std::string const& id) const;
  StatusOr_SharedPtr_LLMCompletionNode GetComponent_LLMCompletionNode(std::string const& id) const;
  StatusOr_SharedPtr_MemoryUpdateNode GetComponent_MemoryUpdateNode(std::string const& id) const;
  StatusOr_SharedPtr_MemoryRetrieveNode GetComponent_MemoryRetrieveNode(std::string const& id) const;
  StatusOr_SharedPtr_RandomCannedTextNode GetComponent_RandomCannedTextNode(std::string const& id) const;
  StatusOr_SharedPtr_SafetyCheckerNode GetComponent_SafetyCheckerNode(std::string const& id) const;
  StatusOr_SharedPtr_STTNode GetComponent_STTNode(std::string const& id) const;
  StatusOr_SharedPtr_TextAggregatorNode GetComponent_TextAggregatorNode(std::string const& id) const;
  StatusOr_SharedPtr_TextChunkingNode GetComponent_TextChunkingNode(std::string const& id) const;
  StatusOr_SharedPtr_TTSNode GetComponent_TTSNode(std::string const& id) const;
  StatusOr_SharedPtr_MCPListToolsNode GetComponent_MCPListToolsNode(std::string const& id) const;
  StatusOr_SharedPtr_MCPCallToolNode GetComponent_MCPCallToolNode(std::string const& id) const;
  StatusOr_LLMInterface GetComponent_LLMInterface(std::string const& id) const;
  StatusOr_STTInterface GetComponent_STTInterface(std::string const& id) const;
  StatusOr_StreamingSTTInterface GetComponent_StreamingSTTInterface(std::string const& id);
  StatusOr_TTSInterface GetComponent_TTSInterface(std::string const& id) const;
  StatusOr_TextEmbedderInterface GetComponent_TextEmbedderInterface(std::string const& id) const;
  StatusOr_KnowledgeInterface GetComponent_KnowledgeInterface(std::string const& id) const;
  StatusOr_MCPClientInterface GetComponent_MCPClientInterface(std::string const& id) const;

  explicit ProcessContext(SwigObj_inworld_ProcessContext* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ProcessContext& operator=(ProcessContext const&) = delete;
  ProcessContext(ProcessContext&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ProcessContext& operator=(ProcessContext&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ProcessContext_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ProcessContext* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ProcessContext* swig_self_;
  bool swig_owns_self_;
};

class vector_BaseData {
public:
  vector_BaseData();
  vector_BaseData(vector_BaseData const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(BaseData const& x);
  BaseData get(int i);
  void set(int i, BaseData const& arg3);
  BaseData safe_get(size_t index) const;
  ~vector_BaseData() {
    if (swig_owns_self_)
      inworld_vector_BaseData_delete(swig_self_);
  }

  explicit vector_BaseData(SwigObj_inworld_vector_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_BaseData& operator=(vector_BaseData const&) = delete;
  vector_BaseData(vector_BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_BaseData& operator=(vector_BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_BaseData* swig_self_;
  bool swig_owns_self_;
};

class vector_Text {
public:
  vector_Text();
  vector_Text(vector_Text const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Text const& x);
  Text get(int i);
  void set(int i, Text const& arg3);
  ~vector_Text() {
    if (swig_owns_self_)
      inworld_vector_Text_delete(swig_self_);
  }

  explicit vector_Text(SwigObj_inworld_vector_Text* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_Text& operator=(vector_Text const&) = delete;
  vector_Text(vector_Text&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_Text& operator=(vector_Text&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_Text_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_Text* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_Text* swig_self_;
  bool swig_owns_self_;
};

class vector_ToolCallResult {
public:
  vector_ToolCallResult();
  vector_ToolCallResult(vector_ToolCallResult const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(ToolCallResult const& x);
  ToolCallResult get(int i);
  void set(int i, ToolCallResult const& arg3);
  ~vector_ToolCallResult() {
    if (swig_owns_self_)
      inworld_vector_ToolCallResult_delete(swig_self_);
  }

  explicit vector_ToolCallResult(SwigObj_inworld_vector_ToolCallResult* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_ToolCallResult& operator=(vector_ToolCallResult const&) = delete;
  vector_ToolCallResult(vector_ToolCallResult&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_ToolCallResult& operator=(vector_ToolCallResult&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_ToolCallResult_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_ToolCallResult* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_ToolCallResult* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_Json {
public:
  StatusOr_Json();
  StatusOr_Json(Json const& value);
  StatusOr_Json(Status const & status);
  bool ok() const;
  Status status() const;
  Json value() const;
  StatusOr_Json(StatusOr_Json const & other);
  ~StatusOr_Json() {
    if (swig_owns_self_)
      inworld_StatusOr_Json_delete(swig_self_);
  }

  explicit StatusOr_Json(SwigObj_inworld_StatusOr_Json* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_Json& operator=(StatusOr_Json const&) = delete;
  StatusOr_Json(StatusOr_Json&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_Json& operator=(StatusOr_Json&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_Json_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_Json* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_Json* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_LLMCompletionRequest {
public:
  StatusOr_LLMCompletionRequest();
  StatusOr_LLMCompletionRequest(LLMCompletionRequest const& value);
  StatusOr_LLMCompletionRequest(Status const & status);
  bool ok() const;
  Status status() const;
  LLMCompletionRequest value() const;
  StatusOr_LLMCompletionRequest(StatusOr_LLMCompletionRequest const & other);
  ~StatusOr_LLMCompletionRequest() {
    if (swig_owns_self_)
      inworld_StatusOr_LLMCompletionRequest_delete(swig_self_);
  }

  explicit StatusOr_LLMCompletionRequest(SwigObj_inworld_StatusOr_LLMCompletionRequest* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_LLMCompletionRequest& operator=(StatusOr_LLMCompletionRequest const&) = delete;
  StatusOr_LLMCompletionRequest(StatusOr_LLMCompletionRequest&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_LLMCompletionRequest& operator=(StatusOr_LLMCompletionRequest&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_LLMCompletionRequest_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_LLMCompletionRequest* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_LLMCompletionRequest* swig_self_;
  bool swig_owns_self_;
};

class BaseData {
public:
  static BaseData null() { return BaseData{(SwigObj_inworld_BaseData*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~BaseData() {
    if (swig_owns_self_)
      inworld_BaseData_delete(swig_self_);
  }
  std::string ToString() const;
  bool is_valid() const;

  explicit BaseData(SwigObj_inworld_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  BaseData(BaseData const&) = delete;
  BaseData& operator=(BaseData const&) = delete;
  BaseData(BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  BaseData& operator=(BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_BaseData* swig_self_;
  bool swig_owns_self_;
};

class Text : public BaseData {
public:
  static Text null() { return Text{(SwigObj_inworld_Text*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  Text();
  Text(std::string const& text);
  std::string value() const;
  bool is_valid() const;
  Text(std::string const& text, std::string const& arg2);
  Text(Text const & other);
  ~Text() {
    if (swig_owns_self_) {
      inworld_Text_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit Text(SwigObj_inworld_Text* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  Text& operator=(Text const&) = delete;
  Text(Text&& obj) = default;
  Text& operator=(Text&& obj) = default;
  SwigObj_inworld_Text* swig_self() const noexcept { return (SwigObj_inworld_Text*)BaseData::swig_self(); }
};

class Audio : public BaseData {
public:
  static Audio null() { return Audio{(SwigObj_inworld_Audio*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  Audio();
  Audio(vector_float const& data, int arg2);
  vector_float data() const;
  int sample_rate() const;
  bool is_valid() const;
  Audio(Audio const & other);
  ~Audio() {
    if (swig_owns_self_) {
      inworld_Audio_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit Audio(SwigObj_inworld_Audio* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  Audio& operator=(Audio const&) = delete;
  Audio(Audio&& obj) = default;
  Audio& operator=(Audio&& obj) = default;
  SwigObj_inworld_Audio* swig_self() const noexcept { return (SwigObj_inworld_Audio*)BaseData::swig_self(); }
};

class TTSOutput {
public:
  TTSOutput(std::string const& text, Audio const& arg2);
  void text(std::string const& text);
  std::string text() const;
  void audio(Audio const& audio);
  Audio audio() const;
  Audio safe_audio() const;
  TTSOutput(TTSOutput const & other);
  ~TTSOutput() {
    if (swig_owns_self_)
      inworld_TTSOutput_delete(swig_self_);
  }

  explicit TTSOutput(SwigObj_inworld_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TTSOutput& operator=(TTSOutput const&) = delete;
  TTSOutput(TTSOutput&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TTSOutput& operator=(TTSOutput&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TTSOutput_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TTSOutput* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TTSOutput* swig_self_;
  bool swig_owns_self_;
};

class PhraseMatch {
public:
  void phrase(std::string const& phrase);
  std::string phrase() const;
  void score(float score);
  float score() const;
  PhraseMatch();
  PhraseMatch(PhraseMatch const & other);
  ~PhraseMatch() {
    if (swig_owns_self_)
      inworld_PhraseMatch_delete(swig_self_);
  }

  explicit PhraseMatch(SwigObj_inworld_PhraseMatch* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  PhraseMatch& operator=(PhraseMatch const&) = delete;
  PhraseMatch(PhraseMatch&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  PhraseMatch& operator=(PhraseMatch&& obj) noexcept {
    if (swig_owns_self_)
      inworld_PhraseMatch_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_PhraseMatch* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_PhraseMatch* swig_self_;
  bool swig_owns_self_;
};

class SafetyResult : public BaseData {
public:
  static SafetyResult null() { return SafetyResult{(SwigObj_inworld_SafetyResult*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  SafetyResult();
  SafetyResult(std::string const& text, bool arg2);
  bool is_safe() const;
  std::string text() const;
  bool is_valid() const;
  SafetyResult(SafetyResult const & other);
  ~SafetyResult() {
    if (swig_owns_self_) {
      inworld_SafetyResult_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit SafetyResult(SwigObj_inworld_SafetyResult* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  SafetyResult& operator=(SafetyResult const&) = delete;
  SafetyResult(SafetyResult&& obj) = default;
  SafetyResult& operator=(SafetyResult&& obj) = default;
  SwigObj_inworld_SafetyResult* swig_self() const noexcept { return (SwigObj_inworld_SafetyResult*)BaseData::swig_self(); }
};

class MatchedKeywords : public BaseData {
public:
  static MatchedKeywords null() { return MatchedKeywords{(SwigObj_inworld_MatchedKeywords*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  MatchedKeywords();
  MatchedKeywords(vector_KeywordMatch const& matches);
  vector_KeywordMatch matches() const;
  bool is_valid() const;
  MatchedKeywords(MatchedKeywords const & other);
  ~MatchedKeywords() {
    if (swig_owns_self_) {
      inworld_MatchedKeywords_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MatchedKeywords(SwigObj_inworld_MatchedKeywords* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  MatchedKeywords& operator=(MatchedKeywords const&) = delete;
  MatchedKeywords(MatchedKeywords&& obj) = default;
  MatchedKeywords& operator=(MatchedKeywords&& obj) = default;
  SwigObj_inworld_MatchedKeywords* swig_self() const noexcept { return (SwigObj_inworld_MatchedKeywords*)BaseData::swig_self(); }
};

class MatchedPhrases : public BaseData {
public:
  static MatchedPhrases null() { return MatchedPhrases{(SwigObj_inworld_MatchedPhrases*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  MatchedPhrases();
  MatchedPhrases(vector_PhraseMatch const& phrase_matches);
  vector_PhraseMatch phrase_matches() const;
  bool is_valid() const;
  MatchedPhrases(MatchedPhrases const & other);
  ~MatchedPhrases() {
    if (swig_owns_self_) {
      inworld_MatchedPhrases_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MatchedPhrases(SwigObj_inworld_MatchedPhrases* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  MatchedPhrases& operator=(MatchedPhrases const&) = delete;
  MatchedPhrases(MatchedPhrases&& obj) = default;
  MatchedPhrases& operator=(MatchedPhrases&& obj) = default;
  SwigObj_inworld_MatchedPhrases* swig_self() const noexcept { return (SwigObj_inworld_MatchedPhrases*)BaseData::swig_self(); }
};

class ClassificationResult : public BaseData {
public:
  static ClassificationResult null() { return ClassificationResult{(SwigObj_inworld_ClassificationResult*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ClassificationResult();
  ClassificationResult(vector_string const& classes);
  vector_string classes() const;
  bool HasClasses() const;
  bool is_valid() const;
  ClassificationResult(ClassificationResult const & other);
  ~ClassificationResult() {
    if (swig_owns_self_) {
      inworld_ClassificationResult_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit ClassificationResult(SwigObj_inworld_ClassificationResult* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  ClassificationResult& operator=(ClassificationResult const&) = delete;
  ClassificationResult(ClassificationResult&& obj) = default;
  ClassificationResult& operator=(ClassificationResult&& obj) = default;
  SwigObj_inworld_ClassificationResult* swig_self() const noexcept { return (SwigObj_inworld_ClassificationResult*)BaseData::swig_self(); }
};

class KnowledgeRecords : public BaseData {
public:
  static KnowledgeRecords null() { return KnowledgeRecords{(SwigObj_inworld_KnowledgeRecords*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  KnowledgeRecords();
  KnowledgeRecords(vector_string const& records);
  vector_string records() const;
  bool is_valid() const;
  KnowledgeRecords(KnowledgeRecords const & other);
  ~KnowledgeRecords() {
    if (swig_owns_self_) {
      inworld_KnowledgeRecords_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit KnowledgeRecords(SwigObj_inworld_KnowledgeRecords* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  KnowledgeRecords& operator=(KnowledgeRecords const&) = delete;
  KnowledgeRecords(KnowledgeRecords&& obj) = default;
  KnowledgeRecords& operator=(KnowledgeRecords&& obj) = default;
  SwigObj_inworld_KnowledgeRecords* swig_self() const noexcept { return (SwigObj_inworld_KnowledgeRecords*)BaseData::swig_self(); }
};

class Error : public BaseData {
public:
  static Error null() { return Error{(SwigObj_inworld_Error*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  Error();
  Error(Status const& status);
  Status status() const;
  bool is_valid() const;
  Error(Error const & other);
  ~Error() {
    if (swig_owns_self_) {
      inworld_Error_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit Error(SwigObj_inworld_Error* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  Error& operator=(Error const&) = delete;
  Error(Error&& obj) = default;
  Error& operator=(Error&& obj) = default;
  SwigObj_inworld_Error* swig_self() const noexcept { return (SwigObj_inworld_Error*)BaseData::swig_self(); }
};

class MatchedIntents : public BaseData {
public:
  static MatchedIntents null() { return MatchedIntents{(SwigObj_inworld_MatchedIntents*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  MatchedIntents();
  MatchedIntents(vector_IntentMatch const& intent_matches);
  vector_IntentMatch intent_matches() const;
  bool is_valid() const;
  MatchedIntents(MatchedIntents const & other);
  ~MatchedIntents() {
    if (swig_owns_self_) {
      inworld_MatchedIntents_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MatchedIntents(SwigObj_inworld_MatchedIntents* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  MatchedIntents& operator=(MatchedIntents const&) = delete;
  MatchedIntents(MatchedIntents&& obj) = default;
  MatchedIntents& operator=(MatchedIntents&& obj) = default;
  SwigObj_inworld_MatchedIntents* swig_self() const noexcept { return (SwigObj_inworld_MatchedIntents*)BaseData::swig_self(); }
};

class GoalAdvancement : public BaseData {
public:
  static GoalAdvancement null() { return GoalAdvancement{(SwigObj_inworld_GoalAdvancement*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  GoalAdvancement();
  vector_string activated_goals() const;
  vector_string completed_goals() const;
  vector_string current_goals() const;
  bool is_valid() const;
  GoalAdvancement(GoalAdvancement const & other);
  ~GoalAdvancement() {
    if (swig_owns_self_) {
      inworld_GoalAdvancement_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit GoalAdvancement(SwigObj_inworld_GoalAdvancement* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  GoalAdvancement& operator=(GoalAdvancement const&) = delete;
  GoalAdvancement(GoalAdvancement&& obj) = default;
  GoalAdvancement& operator=(GoalAdvancement&& obj) = default;
  SwigObj_inworld_GoalAdvancement* swig_self() const noexcept { return (SwigObj_inworld_GoalAdvancement*)BaseData::swig_self(); }
};

class Json : public BaseData {
public:
  static Json null() { return Json{(SwigObj_inworld_Json*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  Json();
  bool is_valid() const;
  static StatusOr_Json inworld_inworld_graphs_Json_FromString__SWIG(std::string const& json_string);
  std::string value_as_string() const;
  Json(Json const & other);
  ~Json() {
    if (swig_owns_self_) {
      inworld_Json_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit Json(SwigObj_inworld_Json* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  Json& operator=(Json const&) = delete;
  Json(Json&& obj) = default;
  Json& operator=(Json&& obj) = default;
  SwigObj_inworld_Json* swig_self() const noexcept { return (SwigObj_inworld_Json*)BaseData::swig_self(); }
};

class ToolCallRequest : public BaseData {
public:
  static ToolCallRequest null() { return ToolCallRequest{(SwigObj_inworld_ToolCallRequest*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ToolCallRequest();
  ToolCallRequest(ToolCalls const& tool_calls);
  ToolCalls tool_calls() const;
  bool is_valid() const;
  ToolCallRequest(ToolCallRequest const & other);
  ~ToolCallRequest() {
    if (swig_owns_self_) {
      inworld_ToolCallRequest_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit ToolCallRequest(SwigObj_inworld_ToolCallRequest* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  ToolCallRequest& operator=(ToolCallRequest const&) = delete;
  ToolCallRequest(ToolCallRequest&& obj) = default;
  ToolCallRequest& operator=(ToolCallRequest&& obj) = default;
  SwigObj_inworld_ToolCallRequest* swig_self() const noexcept { return (SwigObj_inworld_ToolCallRequest*)BaseData::swig_self(); }
};

class ListToolsResponse : public BaseData {
public:
  static ListToolsResponse null() { return ListToolsResponse{(SwigObj_inworld_ListToolsResponse*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ListToolsResponse();
  ListToolsResponse(Vector_Tool const& list_tools);
  Vector_Tool list_tools() const;
  bool is_valid() const;
  ListToolsResponse(ListToolsResponse const & other);
  ~ListToolsResponse() {
    if (swig_owns_self_) {
      inworld_ListToolsResponse_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit ListToolsResponse(SwigObj_inworld_ListToolsResponse* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  ListToolsResponse& operator=(ListToolsResponse const&) = delete;
  ListToolsResponse(ListToolsResponse&& obj) = default;
  ListToolsResponse& operator=(ListToolsResponse&& obj) = default;
  SwigObj_inworld_ListToolsResponse* swig_self() const noexcept { return (SwigObj_inworld_ListToolsResponse*)BaseData::swig_self(); }
};

class LLMChatRequest : public BaseData {
public:
  static LLMChatRequest null() { return LLMChatRequest{(SwigObj_inworld_LLMChatRequest*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  LLMChatRequest();
  LLMChatRequest(Messages const& messages, Vector_Tool const& arg2, optional_ToolChoice const& arg3, ResponseFormat arg4, optional_TextGenerationConfig const& arg5);
  LLMChatRequest(Messages const& messages, Vector_Tool const& arg2, optional_ToolChoice const& arg3, ResponseFormat arg4);
  LLMChatRequest(Messages const& messages, Vector_Tool const& arg2, optional_ToolChoice const& arg3);
  LLMChatRequest(Messages const& messages, Vector_Tool const& arg2);
  LLMChatRequest(Messages const& messages);
  Messages messages() const;
  Vector_Tool tools() const;
  optional_ToolChoice tool_choice() const;
  ResponseFormat response_format() const;
  optional_TextGenerationConfig text_generation_config() const;
  bool is_valid() const;
  LLMChatRequest(LLMChatRequest const & other);
  ~LLMChatRequest() {
    if (swig_owns_self_) {
      inworld_LLMChatRequest_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit LLMChatRequest(SwigObj_inworld_LLMChatRequest* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  LLMChatRequest& operator=(LLMChatRequest const&) = delete;
  LLMChatRequest(LLMChatRequest&& obj) = default;
  LLMChatRequest& operator=(LLMChatRequest&& obj) = default;
  SwigObj_inworld_LLMChatRequest* swig_self() const noexcept { return (SwigObj_inworld_LLMChatRequest*)BaseData::swig_self(); }
};

class LLMChatResponse : public BaseData {
public:
  static LLMChatResponse null() { return LLMChatResponse{(SwigObj_inworld_LLMChatResponse*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  LLMChatResponse();
  LLMChatResponse(Content const& response);
  bool is_streaming() const;
  bool is_valid() const;
  bool has_complete_content() const;
  Content get_response_content() const;
  InputStream_Content get_response_stream() const;
  LLMChatResponse(LLMChatResponse const & other);
  ~LLMChatResponse() {
    if (swig_owns_self_) {
      inworld_LLMChatResponse_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit LLMChatResponse(SwigObj_inworld_LLMChatResponse* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  LLMChatResponse& operator=(LLMChatResponse const&) = delete;
  LLMChatResponse(LLMChatResponse&& obj) = default;
  LLMChatResponse& operator=(LLMChatResponse&& obj) = default;
  SwigObj_inworld_LLMChatResponse* swig_self() const noexcept { return (SwigObj_inworld_LLMChatResponse*)BaseData::swig_self(); }
};

class LLMCompletionRequest : public BaseData {
public:
  static LLMCompletionRequest null() { return LLMCompletionRequest{(SwigObj_inworld_LLMCompletionRequest*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  LLMCompletionRequest();
  LLMCompletionRequest(std::string const& text, optional_TextGenerationConfig const& arg2);
  LLMCompletionRequest(std::string const& text);
  std::string text() const;
  optional_TextGenerationConfig text_generation_config() const;
  bool is_valid() const;
  LLMCompletionRequest(LLMCompletionRequest const & other);
  ~LLMCompletionRequest() {
    if (swig_owns_self_) {
      inworld_LLMCompletionRequest_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit LLMCompletionRequest(SwigObj_inworld_LLMCompletionRequest* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  LLMCompletionRequest& operator=(LLMCompletionRequest const&) = delete;
  LLMCompletionRequest(LLMCompletionRequest&& obj) = default;
  LLMCompletionRequest& operator=(LLMCompletionRequest&& obj) = default;
  SwigObj_inworld_LLMCompletionRequest* swig_self() const noexcept { return (SwigObj_inworld_LLMCompletionRequest*)BaseData::swig_self(); }
};

class LLMCompletionResponse : public BaseData {
public:
  static LLMCompletionResponse null() { return LLMCompletionResponse{(SwigObj_inworld_LLMCompletionResponse*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  LLMCompletionResponse();
  LLMCompletionResponse(std::string const& response);
  bool is_streaming() const;
  bool is_valid() const;
  bool has_complete_content() const;
  std::string get_content_text() const;
  InputStream_string get_input_stream() const;
  LLMCompletionResponse(LLMCompletionResponse const & other);
  ~LLMCompletionResponse() {
    if (swig_owns_self_) {
      inworld_LLMCompletionResponse_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit LLMCompletionResponse(SwigObj_inworld_LLMCompletionResponse* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  LLMCompletionResponse& operator=(LLMCompletionResponse const&) = delete;
  LLMCompletionResponse(LLMCompletionResponse&& obj) = default;
  LLMCompletionResponse& operator=(LLMCompletionResponse&& obj) = default;
  SwigObj_inworld_LLMCompletionResponse* swig_self() const noexcept { return (SwigObj_inworld_LLMCompletionResponse*)BaseData::swig_self(); }
};

class ToolCallResult : public BaseData {
public:
  static ToolCallResult null() { return ToolCallResult{(SwigObj_inworld_ToolCallResult*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ToolCallResult();
  ToolCallResult(std::string const& tool_call_id, std::string const& arg2);
  std::string tool_call_id() const;
  std::string result() const;
  bool is_valid() const;
  ToolCallResult(ToolCallResult const & other);
  ~ToolCallResult() {
    if (swig_owns_self_) {
      inworld_ToolCallResult_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit ToolCallResult(SwigObj_inworld_ToolCallResult* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  ToolCallResult& operator=(ToolCallResult const&) = delete;
  ToolCallResult(ToolCallResult&& obj) = default;
  ToolCallResult& operator=(ToolCallResult&& obj) = default;
  SwigObj_inworld_ToolCallResult* swig_self() const noexcept { return (SwigObj_inworld_ToolCallResult*)BaseData::swig_self(); }
};

class ToolCallResponse : public BaseData {
public:
  static ToolCallResponse null() { return ToolCallResponse{(SwigObj_inworld_ToolCallResponse*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ToolCallResponse();
  bool is_valid() const;
  ToolCallResponse(vector_ToolCallResult const& tool_calls_results);
  vector_ToolCallResult tool_call_results_swig() const;
  ToolCallResponse(ToolCallResponse const & other);
  ~ToolCallResponse() {
    if (swig_owns_self_) {
      inworld_ToolCallResponse_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit ToolCallResponse(SwigObj_inworld_ToolCallResponse* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  ToolCallResponse& operator=(ToolCallResponse const&) = delete;
  ToolCallResponse(ToolCallResponse&& obj) = default;
  ToolCallResponse& operator=(ToolCallResponse&& obj) = default;
  SwigObj_inworld_ToolCallResponse* swig_self() const noexcept { return (SwigObj_inworld_ToolCallResponse*)BaseData::swig_self(); }
};

class TTSRequest : public BaseData {
public:
  static TTSRequest null() { return TTSRequest{(SwigObj_inworld_TTSRequest*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  TTSRequest();
  optional_Voice voice() const;
  optional_SpeechSynthesisConfig synthesis_config() const;
  bool is_valid() const;
  TTSRequest(Text const& text, optional_Voice const& arg2, optional_SpeechSynthesisConfig const& arg3);
  TTSRequest(Text const& text, optional_Voice const& arg2);
  TTSRequest(std::string const& text_content, optional_Voice const& arg2, optional_SpeechSynthesisConfig const& arg3);
  TTSRequest(std::string const& text_content, optional_Voice const& arg2);
  TTSRequest(DataStream_String const& stream, optional_Voice const& arg2, optional_SpeechSynthesisConfig const& arg3);
  TTSRequest(DataStream_String const& stream, optional_Voice const& arg2);
  bool has_text_content() const;
  bool has_stream_content() const;
  Text get_text_content() const;
  InputStream_string get_content_stream() const;
  optional_Voice get_voice() const;
  optional_SpeechSynthesisConfig get_synthesis_config() const;
  TTSRequest(TTSRequest const & other);
  ~TTSRequest() {
    if (swig_owns_self_) {
      inworld_TTSRequest_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TTSRequest(SwigObj_inworld_TTSRequest* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  TTSRequest& operator=(TTSRequest const&) = delete;
  TTSRequest(TTSRequest&& obj) = default;
  TTSRequest& operator=(TTSRequest&& obj) = default;
  SwigObj_inworld_TTSRequest* swig_self() const noexcept { return (SwigObj_inworld_TTSRequest*)BaseData::swig_self(); }
};

class STTRequest : public BaseData {
public:
  static STTRequest null() { return STTRequest{(SwigObj_inworld_STTRequest*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  STTRequest();
  optional_SpeechRecognitionConfig speech_recognition_config() const;
  bool is_valid() const;
  STTRequest(Audio const& audio, optional_SpeechRecognitionConfig const& arg2);
  STTRequest(Audio const& audio);
  STTRequest(DataStream_AudioChunk const& stream, optional_SpeechRecognitionConfig const& arg2);
  STTRequest(DataStream_AudioChunk const& stream);
  bool has_audio_content() const;
  bool has_stream_content() const;
  Audio get_audio_content() const;
  InputStream_AudioChunk get_content_stream() const;
  optional_SpeechRecognitionConfig get_speech_recognition_config() const;
  STTRequest(STTRequest const & other);
  ~STTRequest() {
    if (swig_owns_self_) {
      inworld_STTRequest_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit STTRequest(SwigObj_inworld_STTRequest* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  STTRequest& operator=(STTRequest const&) = delete;
  STTRequest(STTRequest&& obj) = default;
  STTRequest& operator=(STTRequest&& obj) = default;
  SwigObj_inworld_STTRequest* swig_self() const noexcept { return (SwigObj_inworld_STTRequest*)BaseData::swig_self(); }
};

class CustomDataToJsonExecutor {
public:
  CustomDataToJsonExecutor(void * custom_data, void * arg2);
  static void SetNextOutput(std::string const& text);
  CustomDataToJsonExecutor(CustomDataToJsonExecutor const & other);
  ~CustomDataToJsonExecutor() {
    if (swig_owns_self_)
      inworld_CustomDataToJsonExecutor_delete(swig_self_);
  }

  explicit CustomDataToJsonExecutor(SwigObj_inworld_CustomDataToJsonExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomDataToJsonExecutor& operator=(CustomDataToJsonExecutor const&) = delete;
  CustomDataToJsonExecutor(CustomDataToJsonExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomDataToJsonExecutor& operator=(CustomDataToJsonExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomDataToJsonExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomDataToJsonExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomDataToJsonExecutor* swig_self_;
  bool swig_owns_self_;
};

class CustomDataDestructor {
public:
  CustomDataDestructor(void * custom_data, void * arg2);
  CustomDataDestructor(CustomDataDestructor const & other);
  ~CustomDataDestructor() {
    if (swig_owns_self_)
      inworld_CustomDataDestructor_delete(swig_self_);
  }

  explicit CustomDataDestructor(SwigObj_inworld_CustomDataDestructor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomDataDestructor& operator=(CustomDataDestructor const&) = delete;
  CustomDataDestructor(CustomDataDestructor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomDataDestructor& operator=(CustomDataDestructor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomDataDestructor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomDataDestructor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomDataDestructor* swig_self_;
  bool swig_owns_self_;
};

class CustomDataWrapper : public BaseData {
public:
  static CustomDataWrapper null() { return CustomDataWrapper{(SwigObj_inworld_CustomDataWrapper*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  CustomDataWrapper(const char * type_id, void * arg2, CustomDataToJsonExecutor const & arg3, CustomDataDestructor const & arg4);
  virtual ~CustomDataWrapper() {
    if (swig_owns_self_) {
      inworld_CustomDataWrapper_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  const char * type_id() const;
  void * value() const;
  bool is_valid() const;
  CustomDataWrapper(CustomDataWrapper const & other);

  explicit CustomDataWrapper(SwigObj_inworld_CustomDataWrapper* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  CustomDataWrapper& operator=(CustomDataWrapper const&) = delete;
  CustomDataWrapper(CustomDataWrapper&& obj) = default;
  CustomDataWrapper& operator=(CustomDataWrapper&& obj) = default;
  SwigObj_inworld_CustomDataWrapper* swig_self() const noexcept { return (SwigObj_inworld_CustomDataWrapper*)BaseData::swig_self(); }
};

class StatusOr_BaseData {
public:
  StatusOr_BaseData();
  StatusOr_BaseData(BaseData const& value);
  StatusOr_BaseData(Status const & status);
  bool ok() const;
  Status status() const;
  BaseData value() const;
  StatusOr_BaseData(StatusOr_BaseData const & other);
  ~StatusOr_BaseData() {
    if (swig_owns_self_)
      inworld_StatusOr_BaseData_delete(swig_self_);
  }

  explicit StatusOr_BaseData(SwigObj_inworld_StatusOr_BaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_BaseData& operator=(StatusOr_BaseData const&) = delete;
  StatusOr_BaseData(StatusOr_BaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_BaseData& operator=(StatusOr_BaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_BaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_BaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_BaseData* swig_self_;
  bool swig_owns_self_;
};

class Node {
public:
  static Node null() { return Node{(SwigObj_inworld_Node*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~Node() {
    if (swig_owns_self_)
      inworld_Node_delete(swig_self_);
  }
  std::string id() const;
  virtual StatusOr_BaseData Process(ProcessContext & ctx, vector_BaseData const & arg3) const;
  bool is_valid() const;

  explicit Node(SwigObj_inworld_Node* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Node(Node const&) = delete;
  Node& operator=(Node const&) = delete;
  Node(Node&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Node& operator=(Node&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Node_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Node* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Node* swig_self_;
  bool swig_owns_self_;
};

class TypedNodeBase : public Node {
public:
  static TypedNodeBase null() { return TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~TypedNodeBase() {
    if (swig_owns_self_) {
      inworld_TypedNodeBase_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;

  explicit TypedNodeBase(SwigObj_inworld_TypedNodeBase* swig_self, bool swig_owns_self = true) noexcept : Node{(SwigObj_inworld_Node*)swig_self, swig_owns_self} {}
  TypedNodeBase(TypedNodeBase const&) = delete;
  TypedNodeBase& operator=(TypedNodeBase const&) = delete;
  TypedNodeBase(TypedNodeBase&& obj) = default;
  TypedNodeBase& operator=(TypedNodeBase&& obj) = default;
  SwigObj_inworld_TypedNodeBase* swig_self() const noexcept { return (SwigObj_inworld_TypedNodeBase*)Node::swig_self(); }
};

class CustomNodeProcessExecutor {
public:
  CustomNodeProcessExecutor(void * custom_node, void * arg2);
  static vector_BaseData GetLastInputs();
  static ProcessContext GetLastContext();
  static void SetLastOutput(StatusOr_BaseData const& output);
  CustomNodeProcessExecutor(CustomNodeProcessExecutor const & other);
  ~CustomNodeProcessExecutor() {
    if (swig_owns_self_)
      inworld_CustomNodeProcessExecutor_delete(swig_self_);
  }

  explicit CustomNodeProcessExecutor(SwigObj_inworld_CustomNodeProcessExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomNodeProcessExecutor& operator=(CustomNodeProcessExecutor const&) = delete;
  CustomNodeProcessExecutor(CustomNodeProcessExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomNodeProcessExecutor& operator=(CustomNodeProcessExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomNodeProcessExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomNodeProcessExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomNodeProcessExecutor* swig_self_;
  bool swig_owns_self_;
};

class CustomNodeThreadedProcessExecutor {
public:
  CustomNodeThreadedProcessExecutor(void * custom_node, void * arg2);
  static vector_BaseData GetInputs(int execution_id);
  static ProcessContext GetContext(int execution_id);
  static void SetOutput(int execution_id, StatusOr_BaseData const& arg2);
  CustomNodeThreadedProcessExecutor(CustomNodeThreadedProcessExecutor const & other);
  ~CustomNodeThreadedProcessExecutor() {
    if (swig_owns_self_)
      inworld_CustomNodeThreadedProcessExecutor_delete(swig_self_);
  }

  explicit CustomNodeThreadedProcessExecutor(SwigObj_inworld_CustomNodeThreadedProcessExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomNodeThreadedProcessExecutor& operator=(CustomNodeThreadedProcessExecutor const&) = delete;
  CustomNodeThreadedProcessExecutor(CustomNodeThreadedProcessExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomNodeThreadedProcessExecutor& operator=(CustomNodeThreadedProcessExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomNodeThreadedProcessExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomNodeThreadedProcessExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomNodeThreadedProcessExecutor* swig_self_;
  bool swig_owns_self_;
};

class CustomNodeDestructor {
public:
  CustomNodeDestructor(void * context, void * arg2);
  ~CustomNodeDestructor() {
    if (swig_owns_self_)
      inworld_CustomNodeDestructor_delete(swig_self_);
  }
  CustomNodeDestructor(CustomNodeDestructor const & other);

  explicit CustomNodeDestructor(SwigObj_inworld_CustomNodeDestructor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomNodeDestructor& operator=(CustomNodeDestructor const&) = delete;
  CustomNodeDestructor(CustomNodeDestructor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomNodeDestructor& operator=(CustomNodeDestructor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomNodeDestructor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomNodeDestructor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomNodeDestructor* swig_self_;
  bool swig_owns_self_;
};

class CustomNodeWrapper : public Node {
public:
  static CustomNodeWrapper null() { return CustomNodeWrapper{(SwigObj_inworld_CustomNodeWrapper*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  CustomNodeWrapper(std::string const& id, CustomNodeProcessExecutor const & arg2);
  CustomNodeWrapper(std::string const& id, CustomNodeThreadedProcessExecutor const & arg2);
  CustomNodeWrapper(std::string const& id, CustomNodeProcessExecutor const & arg2, CustomNodeDestructor const & arg3);
  CustomNodeWrapper(std::string const& id, CustomNodeThreadedProcessExecutor const & arg2, CustomNodeDestructor const & arg3);
  CustomNodeWrapper(std::string const& id, NodeExecutionConfig const& arg2, CustomNodeProcessExecutor const & arg3);
  CustomNodeWrapper(std::string const& id, NodeExecutionConfig const& arg2, CustomNodeThreadedProcessExecutor const & arg3);
  CustomNodeWrapper(std::string const& id, NodeExecutionConfig const& arg2, CustomNodeProcessExecutor const & arg3, CustomNodeDestructor const & arg4);
  CustomNodeWrapper(std::string const& id, NodeExecutionConfig const& arg2, CustomNodeThreadedProcessExecutor const & arg3, CustomNodeDestructor const & arg4);
  ~CustomNodeWrapper() {
    if (swig_owns_self_) {
      inworld_CustomNodeWrapper_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  bool is_valid() const;
  CustomNodeWrapper(CustomNodeWrapper const & other);

  explicit CustomNodeWrapper(SwigObj_inworld_CustomNodeWrapper* swig_self, bool swig_owns_self = true) noexcept : Node{(SwigObj_inworld_Node*)swig_self, swig_owns_self} {}
  CustomNodeWrapper& operator=(CustomNodeWrapper const&) = delete;
  CustomNodeWrapper(CustomNodeWrapper&& obj) = default;
  CustomNodeWrapper& operator=(CustomNodeWrapper&& obj) = default;
  SwigObj_inworld_CustomNodeWrapper* swig_self() const noexcept { return (SwigObj_inworld_CustomNodeWrapper*)Node::swig_self(); }
};

class TypedNode_Text_Text : public TypedNodeBase {
public:
  static TypedNode_Text_Text null() { return TypedNode_Text_Text{(SwigObj_inworld_TypedNode_Text_Text*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_Text_Text() {
    if (swig_owns_self_) {
      inworld_TypedNode_Text_Text_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_Text_Text(SwigObj_inworld_TypedNode_Text_Text* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_Text_Text(TypedNode_Text_Text const&) = delete;
  TypedNode_Text_Text& operator=(TypedNode_Text_Text const&) = delete;
  TypedNode_Text_Text(TypedNode_Text_Text&& obj) = default;
  TypedNode_Text_Text& operator=(TypedNode_Text_Text&& obj) = default;
  SwigObj_inworld_TypedNode_Text_Text* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_Text_Text*)TypedNodeBase::swig_self(); }
};

class TypedNode_Text_Audio : public TypedNodeBase {
public:
  static TypedNode_Text_Audio null() { return TypedNode_Text_Audio{(SwigObj_inworld_TypedNode_Text_Audio*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_Text_Audio() {
    if (swig_owns_self_) {
      inworld_TypedNode_Text_Audio_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_Text_Audio(SwigObj_inworld_TypedNode_Text_Audio* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_Text_Audio(TypedNode_Text_Audio const&) = delete;
  TypedNode_Text_Audio& operator=(TypedNode_Text_Audio const&) = delete;
  TypedNode_Text_Audio(TypedNode_Text_Audio&& obj) = default;
  TypedNode_Text_Audio& operator=(TypedNode_Text_Audio&& obj) = default;
  SwigObj_inworld_TypedNode_Text_Audio* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_Text_Audio*)TypedNodeBase::swig_self(); }
};

class TypedNode_BaseData_Text : public TypedNodeBase {
public:
  static TypedNode_BaseData_Text null() { return TypedNode_BaseData_Text{(SwigObj_inworld_TypedNode_BaseData_Text*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_BaseData_Text() {
    if (swig_owns_self_) {
      inworld_TypedNode_BaseData_Text_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_BaseData_Text(SwigObj_inworld_TypedNode_BaseData_Text* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_BaseData_Text(TypedNode_BaseData_Text const&) = delete;
  TypedNode_BaseData_Text& operator=(TypedNode_BaseData_Text const&) = delete;
  TypedNode_BaseData_Text(TypedNode_BaseData_Text&& obj) = default;
  TypedNode_BaseData_Text& operator=(TypedNode_BaseData_Text&& obj) = default;
  SwigObj_inworld_TypedNode_BaseData_Text* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_BaseData_Text*)TypedNodeBase::swig_self(); }
};

class TypedNode_TTSOutputStream_Text_DataStream_String : public TypedNodeBase {
public:
  static TypedNode_TTSOutputStream_Text_DataStream_String null() { return TypedNode_TTSOutputStream_Text_DataStream_String{(SwigObj_inworld_TypedNode_TTSOutputStream_Text_DataStream_String*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_TTSOutputStream_Text_DataStream_String() {
    if (swig_owns_self_) {
      inworld_TypedNode_TTSOutputStream_Text_DataStream_String_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_TTSOutputStream_Text_DataStream_String(SwigObj_inworld_TypedNode_TTSOutputStream_Text_DataStream_String* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_TTSOutputStream_Text_DataStream_String(TypedNode_TTSOutputStream_Text_DataStream_String const&) = delete;
  TypedNode_TTSOutputStream_Text_DataStream_String& operator=(TypedNode_TTSOutputStream_Text_DataStream_String const&) = delete;
  TypedNode_TTSOutputStream_Text_DataStream_String(TypedNode_TTSOutputStream_Text_DataStream_String&& obj) = default;
  TypedNode_TTSOutputStream_Text_DataStream_String& operator=(TypedNode_TTSOutputStream_Text_DataStream_String&& obj) = default;
  SwigObj_inworld_TypedNode_TTSOutputStream_Text_DataStream_String* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_TTSOutputStream_Text_DataStream_String*)TypedNodeBase::swig_self(); }
};

class TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest : public TypedNodeBase {
public:
  static TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest null() { return TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest{(SwigObj_inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest() {
    if (swig_owns_self_) {
      inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest(SwigObj_inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest(TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest const&) = delete;
  TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest& operator=(TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest const&) = delete;
  TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest(TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest&& obj) = default;
  TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest& operator=(TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest&& obj) = default;
  SwigObj_inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest*)TypedNodeBase::swig_self(); }
};

class TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text : public TypedNodeBase {
public:
  static TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text null() { return TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text{(SwigObj_inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text() {
    if (swig_owns_self_) {
      inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text(SwigObj_inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text(TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text const&) = delete;
  TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text& operator=(TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text const&) = delete;
  TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text(TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text&& obj) = default;
  TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text& operator=(TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text&& obj) = default;
  SwigObj_inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text*)TypedNodeBase::swig_self(); }
};

class TypedNode_KnowledgeRecords_Text : public TypedNodeBase {
public:
  static TypedNode_KnowledgeRecords_Text null() { return TypedNode_KnowledgeRecords_Text{(SwigObj_inworld_TypedNode_KnowledgeRecords_Text*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_KnowledgeRecords_Text() {
    if (swig_owns_self_) {
      inworld_TypedNode_KnowledgeRecords_Text_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_KnowledgeRecords_Text(SwigObj_inworld_TypedNode_KnowledgeRecords_Text* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_KnowledgeRecords_Text(TypedNode_KnowledgeRecords_Text const&) = delete;
  TypedNode_KnowledgeRecords_Text& operator=(TypedNode_KnowledgeRecords_Text const&) = delete;
  TypedNode_KnowledgeRecords_Text(TypedNode_KnowledgeRecords_Text&& obj) = default;
  TypedNode_KnowledgeRecords_Text& operator=(TypedNode_KnowledgeRecords_Text&& obj) = default;
  SwigObj_inworld_TypedNode_KnowledgeRecords_Text* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_KnowledgeRecords_Text*)TypedNodeBase::swig_self(); }
};

class TypedNode_Text_Variant_Text_DataStream_String : public TypedNodeBase {
public:
  static TypedNode_Text_Variant_Text_DataStream_String null() { return TypedNode_Text_Variant_Text_DataStream_String{(SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_Text_Variant_Text_DataStream_String() {
    if (swig_owns_self_) {
      inworld_TypedNode_Text_Variant_Text_DataStream_String_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_Text_Variant_Text_DataStream_String(SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_Text_Variant_Text_DataStream_String(TypedNode_Text_Variant_Text_DataStream_String const&) = delete;
  TypedNode_Text_Variant_Text_DataStream_String& operator=(TypedNode_Text_Variant_Text_DataStream_String const&) = delete;
  TypedNode_Text_Variant_Text_DataStream_String(TypedNode_Text_Variant_Text_DataStream_String&& obj) = default;
  TypedNode_Text_Variant_Text_DataStream_String& operator=(TypedNode_Text_Variant_Text_DataStream_String&& obj) = default;
  SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String*)TypedNodeBase::swig_self(); }
};

class TypedNode_DataStream_String_Variant_Text_DataStream_String : public TypedNodeBase {
public:
  static TypedNode_DataStream_String_Variant_Text_DataStream_String null() { return TypedNode_DataStream_String_Variant_Text_DataStream_String{(SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_DataStream_String_Variant_Text_DataStream_String() {
    if (swig_owns_self_) {
      inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_DataStream_String_Variant_Text_DataStream_String(SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_DataStream_String_Variant_Text_DataStream_String(TypedNode_DataStream_String_Variant_Text_DataStream_String const&) = delete;
  TypedNode_DataStream_String_Variant_Text_DataStream_String& operator=(TypedNode_DataStream_String_Variant_Text_DataStream_String const&) = delete;
  TypedNode_DataStream_String_Variant_Text_DataStream_String(TypedNode_DataStream_String_Variant_Text_DataStream_String&& obj) = default;
  TypedNode_DataStream_String_Variant_Text_DataStream_String& operator=(TypedNode_DataStream_String_Variant_Text_DataStream_String&& obj) = default;
  SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String*)TypedNodeBase::swig_self(); }
};

class TypedNode_BaseData_LLMChatRequest : public TypedNodeBase {
public:
  static TypedNode_BaseData_LLMChatRequest null() { return TypedNode_BaseData_LLMChatRequest{(SwigObj_inworld_TypedNode_BaseData_LLMChatRequest*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_BaseData_LLMChatRequest() {
    if (swig_owns_self_) {
      inworld_TypedNode_BaseData_LLMChatRequest_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_BaseData_LLMChatRequest(SwigObj_inworld_TypedNode_BaseData_LLMChatRequest* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_BaseData_LLMChatRequest(TypedNode_BaseData_LLMChatRequest const&) = delete;
  TypedNode_BaseData_LLMChatRequest& operator=(TypedNode_BaseData_LLMChatRequest const&) = delete;
  TypedNode_BaseData_LLMChatRequest(TypedNode_BaseData_LLMChatRequest&& obj) = default;
  TypedNode_BaseData_LLMChatRequest& operator=(TypedNode_BaseData_LLMChatRequest&& obj) = default;
  SwigObj_inworld_TypedNode_BaseData_LLMChatRequest* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_BaseData_LLMChatRequest*)TypedNodeBase::swig_self(); }
};

class TypedNode_Text_Variant_Audio_DataStream_AudioChunk : public TypedNodeBase {
public:
  static TypedNode_Text_Variant_Audio_DataStream_AudioChunk null() { return TypedNode_Text_Variant_Audio_DataStream_AudioChunk{(SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_Text_Variant_Audio_DataStream_AudioChunk() {
    if (swig_owns_self_) {
      inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_Text_Variant_Audio_DataStream_AudioChunk(SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_Text_Variant_Audio_DataStream_AudioChunk(TypedNode_Text_Variant_Audio_DataStream_AudioChunk const&) = delete;
  TypedNode_Text_Variant_Audio_DataStream_AudioChunk& operator=(TypedNode_Text_Variant_Audio_DataStream_AudioChunk const&) = delete;
  TypedNode_Text_Variant_Audio_DataStream_AudioChunk(TypedNode_Text_Variant_Audio_DataStream_AudioChunk&& obj) = default;
  TypedNode_Text_Variant_Audio_DataStream_AudioChunk& operator=(TypedNode_Text_Variant_Audio_DataStream_AudioChunk&& obj) = default;
  SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk*)TypedNodeBase::swig_self(); }
};

class TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse : public TypedNodeBase {
public:
  static TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse null() { return TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse{(SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse() {
    if (swig_owns_self_) {
      inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse(SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse(TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse const&) = delete;
  TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse& operator=(TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse const&) = delete;
  TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse(TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse&& obj) = default;
  TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse& operator=(TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse&& obj) = default;
  SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse*)TypedNodeBase::swig_self(); }
};

class TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse : public TypedNodeBase {
public:
  static TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse null() { return TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse{(SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse() {
    if (swig_owns_self_) {
      inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse(SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse(TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse const&) = delete;
  TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse& operator=(TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse const&) = delete;
  TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse(TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse&& obj) = default;
  TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse& operator=(TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse&& obj) = default;
  SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse*)TypedNodeBase::swig_self(); }
};

class TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest : public TypedNodeBase {
public:
  static TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest null() { return TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest{(SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest() {
    if (swig_owns_self_) {
      inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest(SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest(TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest const&) = delete;
  TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest& operator=(TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest const&) = delete;
  TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest(TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest&& obj) = default;
  TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest& operator=(TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest&& obj) = default;
  SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest*)TypedNodeBase::swig_self(); }
};

class HashSet_String {
public:
  HashSet_String();
  ~HashSet_String() {
    if (swig_owns_self_)
      inworld_HashSet_String_delete(swig_self_);
  }
  size_t size() const;
  bool empty() const;
  void clear();
  bool __contains__(std::string const& key);
  void add(std::string const& key);
  HashSet_String(HashSet_String const & other);

  explicit HashSet_String(SwigObj_inworld_HashSet_String* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  HashSet_String& operator=(HashSet_String const&) = delete;
  HashSet_String(HashSet_String&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  HashSet_String& operator=(HashSet_String&& obj) noexcept {
    if (swig_owns_self_)
      inworld_HashSet_String_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_HashSet_String* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_HashSet_String* swig_self_;
  bool swig_owns_self_;
};

class HashMap_StringToHashSetString {
public:
  HashMap_StringToHashSetString();
  ~HashMap_StringToHashSetString() {
    if (swig_owns_self_)
      inworld_HashMap_StringToHashSetString_delete(swig_self_);
  }
  size_t size() const;
  bool empty() const;
  void clear();
  HashSet_String __getitem__(std::string const& key);
  void __setitem__(std::string const& key, HashSet_String const & arg3);
  bool __contains__(std::string const& key);
  HashMap_StringToHashSetString(HashMap_StringToHashSetString const & other);

  explicit HashMap_StringToHashSetString(SwigObj_inworld_HashMap_StringToHashSetString* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  HashMap_StringToHashSetString& operator=(HashMap_StringToHashSetString const&) = delete;
  HashMap_StringToHashSetString(HashMap_StringToHashSetString&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  HashMap_StringToHashSetString& operator=(HashMap_StringToHashSetString&& obj) noexcept {
    if (swig_owns_self_)
      inworld_HashMap_StringToHashSetString_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_HashMap_StringToHashSetString* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_HashMap_StringToHashSetString* swig_self_;
  bool swig_owns_self_;
};

class Edge {
public:
  void to_node_id(std::string const& to_node_id);
  std::string to_node_id() const;
  void is_required(bool is_required);
  bool is_required() const;
  void is_loop_edge(bool is_loop_edge);
  bool is_loop_edge() const;
  Edge();
  Edge(Edge const & other);
  ~Edge() {
    if (swig_owns_self_)
      inworld_Edge_delete(swig_self_);
  }

  explicit Edge(SwigObj_inworld_Edge* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Edge& operator=(Edge const&) = delete;
  Edge(Edge&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Edge& operator=(Edge&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Edge_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Edge* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Edge* swig_self_;
  bool swig_owns_self_;
};

class Loop {
public:
  void entry_node_id(std::string const& entry_node_id);
  std::string entry_node_id() const;
  void loop_paths(HashMap_StringToHashSetString * loop_paths);
  HashMap_StringToHashSetString * loop_paths() const;
  Loop();
  Loop(Loop const & other);
  ~Loop() {
    if (swig_owns_self_)
      inworld_Loop_delete(swig_self_);
  }

  explicit Loop(SwigObj_inworld_Loop* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Loop& operator=(Loop const&) = delete;
  Loop(Loop&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Loop& operator=(Loop&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Loop_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Loop* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Loop* swig_self_;
  bool swig_owns_self_;
};

class HashMap_StringToNode {
public:
  HashMap_StringToNode();
  ~HashMap_StringToNode() {
    if (swig_owns_self_)
      inworld_HashMap_StringToNode_delete(swig_self_);
  }
  size_t size() const;
  bool empty() const;
  void clear();
  Node __getitem__(std::string const& key);
  void __setitem__(std::string const& key, Node const& arg3);
  bool __contains__(std::string const& key);
  HashMap_StringToNode(HashMap_StringToNode const & other);

  explicit HashMap_StringToNode(SwigObj_inworld_HashMap_StringToNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  HashMap_StringToNode& operator=(HashMap_StringToNode const&) = delete;
  HashMap_StringToNode(HashMap_StringToNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  HashMap_StringToNode& operator=(HashMap_StringToNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_HashMap_StringToNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_HashMap_StringToNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_HashMap_StringToNode* swig_self_;
  bool swig_owns_self_;
};

class HashMap_StringToLoop {
public:
  HashMap_StringToLoop();
  ~HashMap_StringToLoop() {
    if (swig_owns_self_)
      inworld_HashMap_StringToLoop_delete(swig_self_);
  }
  size_t size() const;
  bool empty() const;
  void clear();
  Loop __getitem__(std::string const& key);
  void __setitem__(std::string const& key, Loop const & arg3);
  bool __contains__(std::string const& key);
  HashMap_StringToLoop(HashMap_StringToLoop const & other);

  explicit HashMap_StringToLoop(SwigObj_inworld_HashMap_StringToLoop* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  HashMap_StringToLoop& operator=(HashMap_StringToLoop const&) = delete;
  HashMap_StringToLoop(HashMap_StringToLoop&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  HashMap_StringToLoop& operator=(HashMap_StringToLoop&& obj) noexcept {
    if (swig_owns_self_)
      inworld_HashMap_StringToLoop_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_HashMap_StringToLoop* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_HashMap_StringToLoop* swig_self_;
  bool swig_owns_self_;
};

class CompiledGraphInterface {
public:
  virtual ~CompiledGraphInterface() {
    if (swig_owns_self_)
      inworld_CompiledGraphInterface_delete(swig_self_);
  }
  virtual std::string id() const;
  virtual HashMap_StringToNode Nodes() const;
  virtual HashSet_String StartNodes() const;
  virtual HashSet_String EndNodes() const;
  virtual HashMap_StringToLoop Loops() const;
  virtual vector_Edge Edges(std::string const& node_id) const;
  virtual vector_string ParentNodeIds(std::string const& node_id) const;
  virtual Status Visualize(std::string const& output_path) const;

  explicit CompiledGraphInterface(SwigObj_inworld_CompiledGraphInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CompiledGraphInterface(CompiledGraphInterface const&) = delete;
  CompiledGraphInterface& operator=(CompiledGraphInterface const&) = delete;
  CompiledGraphInterface(CompiledGraphInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CompiledGraphInterface& operator=(CompiledGraphInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CompiledGraphInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CompiledGraphInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CompiledGraphInterface* swig_self_;
  bool swig_owns_self_;
};

class DataStore {
public:
  static DataStore null() { return DataStore{(SwigObj_inworld_DataStore*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  DataStore();
  ~DataStore() {
    if (swig_owns_self_)
      inworld_DataStore_delete(swig_self_);
  }
  bool Add(std::string const& key, BaseData const& arg3);
  StatusOr_BaseData Get(std::string const& key) const;
  BaseData GetOrDefault(std::string const& key, BaseData const& arg3) const;
  bool Contains(std::string const& key) const;
  vector_string GetKeys() const;
  size_t Size() const;
  bool Empty() const;
  bool is_valid() const;

  explicit DataStore(SwigObj_inworld_DataStore* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  DataStore(DataStore const&) = delete;
  DataStore& operator=(DataStore const&) = delete;
  DataStore(DataStore&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  DataStore& operator=(DataStore&& obj) noexcept {
    if (swig_owns_self_)
      inworld_DataStore_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_DataStore* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_DataStore* swig_self_;
  bool swig_owns_self_;
};

class EdgeContext {
public:
  static EdgeContext null() { return EdgeContext{(SwigObj_inworld_EdgeContext*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static EdgeContext Create(std::string const& execution_id, DataStore const& arg2, CancellationContext const& arg3);
  ~EdgeContext() {
    if (swig_owns_self_)
      inworld_EdgeContext_delete(swig_self_);
  }
  std::string GetExecutionId() const;
  DataStore GetDataStore() const;
  bool IsCancelled() const;
  CancellationContext GetCancellationContext() const;
  bool is_valid() const;

  explicit EdgeContext(SwigObj_inworld_EdgeContext* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  EdgeContext(EdgeContext const&) = delete;
  EdgeContext& operator=(EdgeContext const&) = delete;
  EdgeContext(EdgeContext&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  EdgeContext& operator=(EdgeContext&& obj) noexcept {
    if (swig_owns_self_)
      inworld_EdgeContext_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_EdgeContext* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_EdgeContext* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_CompiledGraphInterfacePtr {
public:
  StatusOr_CompiledGraphInterfacePtr();
  StatusOr_CompiledGraphInterfacePtr(CompiledGraphInterface * value);
  StatusOr_CompiledGraphInterfacePtr(Status const & status);
  bool ok() const;
  Status status() const;
  CompiledGraphInterface * value() const;
  StatusOr_CompiledGraphInterfacePtr(StatusOr_CompiledGraphInterfacePtr const & other);
  ~StatusOr_CompiledGraphInterfacePtr() {
    if (swig_owns_self_)
      inworld_StatusOr_CompiledGraphInterfacePtr_delete(swig_self_);
  }

  explicit StatusOr_CompiledGraphInterfacePtr(SwigObj_inworld_StatusOr_CompiledGraphInterfacePtr* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_CompiledGraphInterfacePtr& operator=(StatusOr_CompiledGraphInterfacePtr const&) = delete;
  StatusOr_CompiledGraphInterfacePtr(StatusOr_CompiledGraphInterfacePtr&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_CompiledGraphInterfacePtr& operator=(StatusOr_CompiledGraphInterfacePtr&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_CompiledGraphInterfacePtr_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_CompiledGraphInterfacePtr* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_CompiledGraphInterfacePtr* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_ConfigParserPtr {
public:
  StatusOr_ConfigParserPtr();
  StatusOr_ConfigParserPtr(ConfigParser * value);
  StatusOr_ConfigParserPtr(Status const & status);
  bool ok() const;
  Status status() const;
  ConfigParser * value() const;
  StatusOr_ConfigParserPtr(StatusOr_ConfigParserPtr const & other);
  ~StatusOr_ConfigParserPtr() {
    if (swig_owns_self_)
      inworld_StatusOr_ConfigParserPtr_delete(swig_self_);
  }

  explicit StatusOr_ConfigParserPtr(SwigObj_inworld_StatusOr_ConfigParserPtr* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_ConfigParserPtr& operator=(StatusOr_ConfigParserPtr const&) = delete;
  StatusOr_ConfigParserPtr(StatusOr_ConfigParserPtr&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_ConfigParserPtr& operator=(StatusOr_ConfigParserPtr&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_ConfigParserPtr_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_ConfigParserPtr* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_ConfigParserPtr* swig_self_;
  bool swig_owns_self_;
};

class ConfigParser {
public:
  ~ConfigParser() {
    if (swig_owns_self_)
      inworld_ConfigParser_delete(swig_self_);
  }
  static StatusOr_ConfigParserPtr inworld_inworld_graphs_ConfigParser_CreateConfigParser__SWIG();
  static StatusOr_ConfigParserPtr inworld_inworld_graphs_ConfigParser_CreateConfigParserWithDefaults__SWIG(HashMap_StringToString const & default_substitutions);
  StatusOr_CompiledGraphInterfacePtr ParseGraphFromJsonString(const char * config_string);
  StatusOr_CompiledGraphInterfacePtr ParseGraphFromJsonStringWithSubstitutions(const char * config_string, HashMap_StringToString const & arg3);

  explicit ConfigParser(SwigObj_inworld_ConfigParser* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ConfigParser(ConfigParser const&) = delete;
  ConfigParser& operator=(ConfigParser const&) = delete;
  ConfigParser(ConfigParser&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ConfigParser& operator=(ConfigParser&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ConfigParser_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ConfigParser* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ConfigParser* swig_self_;
  bool swig_owns_self_;
};

class Graph {
public:
  Graph(std::string const& id);
  ~Graph() {
    if (swig_owns_self_)
      inworld_Graph_delete(swig_self_);
  }
  void AddNode(Node const& node);
  void SetAsStart(Node const& node);
  void SetAsEnd(Node const& node);
  StatusOr_CompiledGraphInterfacePtr CompileAndReturnRaw();
  EdgeWrapper CreateEdge(Node const& from_node, Node const& arg3);
  StatusOr_CreationContext GetCreationContextHelper();
  Status AddComponent_LLMInterface(std::string const& id, LLMInterface const& arg3);
  Status AddComponent_STTInterface(std::string const& id, STTInterface const& arg3);
  Status AddComponent_StreamingSTTInterface(std::string const& id, StreamingSTTInterface const& arg3);
  Status AddComponent_TTSInterface(std::string const& id, TTSInterface const& arg3);
  Status AddComponent_TextEmbedderInterface(std::string const& id, TextEmbedderInterface const& arg3);
  Status AddComponent_KnowledgeInterface(std::string const& id, KnowledgeInterface const& arg3);
  Status AddComponent_MCPClientInterface(std::string const& id, MCPClientInterface const& arg3);

  explicit Graph(SwigObj_inworld_Graph* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Graph(Graph const&) = delete;
  Graph& operator=(Graph const&) = delete;
  Graph(Graph&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Graph& operator=(Graph&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Graph_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Graph* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Graph* swig_self_;
  bool swig_owns_self_;
};

class EdgeConditionExecutor {
public:
  EdgeConditionExecutor(void * opaque_callback, void * arg2);
  EdgeConditionExecutor(EdgeConditionExecutor const & other);
  static EdgeContext GetLastEdgeContext();
  static BaseData GetLastInput();
  static void SetNextOutput(bool output);
  static void SetNextError(std::string const& error);
  ~EdgeConditionExecutor() {
    if (swig_owns_self_)
      inworld_EdgeConditionExecutor_delete(swig_self_);
  }

  explicit EdgeConditionExecutor(SwigObj_inworld_EdgeConditionExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  EdgeConditionExecutor& operator=(EdgeConditionExecutor const&) = delete;
  EdgeConditionExecutor(EdgeConditionExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  EdgeConditionExecutor& operator=(EdgeConditionExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_EdgeConditionExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_EdgeConditionExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_EdgeConditionExecutor* swig_self_;
  bool swig_owns_self_;
};

class EdgeConditionThreadedExecutor {
public:
  EdgeConditionThreadedExecutor(void * context, void * arg2);
  ~EdgeConditionThreadedExecutor() {
    if (swig_owns_self_)
      inworld_EdgeConditionThreadedExecutor_delete(swig_self_);
  }
  static BaseData GetInput(int execution_id);
  static EdgeContext GetEdgeContext(int execution_id);
  static void SetOutput(int execution_id, bool arg2);
  static void SetError(int execution_id, std::string const& arg2);
  EdgeConditionThreadedExecutor(EdgeConditionThreadedExecutor const & other);

  explicit EdgeConditionThreadedExecutor(SwigObj_inworld_EdgeConditionThreadedExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  EdgeConditionThreadedExecutor& operator=(EdgeConditionThreadedExecutor const&) = delete;
  EdgeConditionThreadedExecutor(EdgeConditionThreadedExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  EdgeConditionThreadedExecutor& operator=(EdgeConditionThreadedExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_EdgeConditionThreadedExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_EdgeConditionThreadedExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_EdgeConditionThreadedExecutor* swig_self_;
  bool swig_owns_self_;
};

class EdgeWrapper {
public:
  EdgeWrapper(EdgeWrapper const & other);
  void SetCondition(EdgeConditionExecutor const & condition);
  void SetCondition(EdgeConditionThreadedExecutor const & condition);
  void SetToOptional();
  void SetToLoop();
  void Build();
  ~EdgeWrapper() {
    if (swig_owns_self_)
      inworld_EdgeWrapper_delete(swig_self_);
  }

  explicit EdgeWrapper(SwigObj_inworld_EdgeWrapper* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  EdgeWrapper& operator=(EdgeWrapper const&) = delete;
  EdgeWrapper(EdgeWrapper&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  EdgeWrapper& operator=(EdgeWrapper&& obj) noexcept {
    if (swig_owns_self_)
      inworld_EdgeWrapper_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_EdgeWrapper* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_EdgeWrapper* swig_self_;
  bool swig_owns_self_;
};

class MCPClientInterface {
public:
  static MCPClientInterface null() { return MCPClientInterface{(SwigObj_inworld_MCPClientInterface*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~MCPClientInterface() {
    if (swig_owns_self_)
      inworld_MCPClientInterface_delete(swig_self_);
  }
  virtual StatusOr_Tools ListTools() const;
  bool is_valid() const;
  StatusOr_string Call(ToolCall const & tool_call) const;

  explicit MCPClientInterface(SwigObj_inworld_MCPClientInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MCPClientInterface(MCPClientInterface const&) = delete;
  MCPClientInterface& operator=(MCPClientInterface const&) = delete;
  MCPClientInterface(MCPClientInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MCPClientInterface& operator=(MCPClientInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MCPClientInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MCPClientInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MCPClientInterface* swig_self_;
  bool swig_owns_self_;
};

class vector_Node {
public:
  vector_Node();
  vector_Node(vector_Node const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Node const& x);
  Node get(int i);
  void set(int i, Node const& arg3);
  ~vector_Node() {
    if (swig_owns_self_)
      inworld_vector_Node_delete(swig_self_);
  }

  explicit vector_Node(SwigObj_inworld_vector_Node* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_Node& operator=(vector_Node const&) = delete;
  vector_Node(vector_Node&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_Node& operator=(vector_Node&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_Node_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_Node* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_Node* swig_self_;
  bool swig_owns_self_;
};

class LinearGraph {
public:
  LinearGraph(std::string const& id, vector_Node const & arg2);
  ~LinearGraph() {
    if (swig_owns_self_)
      inworld_LinearGraph_delete(swig_self_);
  }
  void AddNode(Node const& node);
  StatusOr_CreationContext GetCreationContextHelper() const;
  Status AddComponent_LLMInterface(std::string const& id, LLMInterface const& arg3);
  Status AddComponent_STTInterface(std::string const& id, STTInterface const& arg3);
  Status AddComponent_StreamingSTTInterface(std::string const& id, StreamingSTTInterface const& arg3);
  Status AddComponent_TTSInterface(std::string const& id, TTSInterface const& arg3);
  Status AddComponent_TextEmbedderInterface(std::string const& id, TextEmbedderInterface const& arg3);
  Status AddComponent_KnowledgeInterface(std::string const& id, KnowledgeInterface const& arg3);
  Status AddComponent_MCPClientInterface(std::string const& id, MCPClientInterface const& arg3);

  explicit LinearGraph(SwigObj_inworld_LinearGraph* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  LinearGraph(LinearGraph const&) = delete;
  LinearGraph& operator=(LinearGraph const&) = delete;
  LinearGraph(LinearGraph&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  LinearGraph& operator=(LinearGraph&& obj) noexcept {
    if (swig_owns_self_)
      inworld_LinearGraph_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_LinearGraph* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_LinearGraph* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_TTSOutput {
public:
  StatusOr_TTSOutput();
  StatusOr_TTSOutput(TTSOutput const & value);
  StatusOr_TTSOutput(Status const & status);
  bool ok() const;
  Status status() const;
  TTSOutput value() const;
  StatusOr_TTSOutput(StatusOr_TTSOutput const & other);
  ~StatusOr_TTSOutput() {
    if (swig_owns_self_)
      inworld_StatusOr_TTSOutput_delete(swig_self_);
  }

  explicit StatusOr_TTSOutput(SwigObj_inworld_StatusOr_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_TTSOutput& operator=(StatusOr_TTSOutput const&) = delete;
  StatusOr_TTSOutput(StatusOr_TTSOutput&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_TTSOutput& operator=(StatusOr_TTSOutput&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_TTSOutput_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_TTSOutput* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_TTSOutput* swig_self_;
  bool swig_owns_self_;
};

class DataStream_TTSOutput : public BaseData {
public:
  static DataStream_TTSOutput null() { return DataStream_TTSOutput{(SwigObj_inworld_DataStream_TTSOutput*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  DataStream_TTSOutput(InputStream_TTSOutput const& stream, ProcessContext const & arg2);
  DataStream_TTSOutput(InputStream_TTSOutput const& stream);
  ~DataStream_TTSOutput() {
    if (swig_owns_self_) {
      inworld_DataStream_TTSOutput_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  DataStream_TTSOutput(DataStream_TTSOutput const & other);
  InputStream_TTSOutput stream() const;
  CancellationContext cancellation_context() const;
  bool is_valid() const;

  explicit DataStream_TTSOutput(SwigObj_inworld_DataStream_TTSOutput* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  DataStream_TTSOutput& operator=(DataStream_TTSOutput const&) = delete;
  DataStream_TTSOutput(DataStream_TTSOutput&& obj) = default;
  DataStream_TTSOutput& operator=(DataStream_TTSOutput&& obj) = default;
  SwigObj_inworld_DataStream_TTSOutput* swig_self() const noexcept { return (SwigObj_inworld_DataStream_TTSOutput*)BaseData::swig_self(); }
};

class DataStream_String : public BaseData {
public:
  static DataStream_String null() { return DataStream_String{(SwigObj_inworld_DataStream_String*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  DataStream_String(InputStream_string const& stream, ProcessContext const & arg2);
  DataStream_String(InputStream_string const& stream);
  ~DataStream_String() {
    if (swig_owns_self_) {
      inworld_DataStream_String_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  DataStream_String(DataStream_String const & other);
  InputStream_string stream() const;
  CancellationContext cancellation_context() const;
  bool is_valid() const;

  explicit DataStream_String(SwigObj_inworld_DataStream_String* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  DataStream_String& operator=(DataStream_String const&) = delete;
  DataStream_String(DataStream_String&& obj) = default;
  DataStream_String& operator=(DataStream_String&& obj) = default;
  SwigObj_inworld_DataStream_String* swig_self() const noexcept { return (SwigObj_inworld_DataStream_String*)BaseData::swig_self(); }
};

class DataStream_Content : public BaseData {
public:
  static DataStream_Content null() { return DataStream_Content{(SwigObj_inworld_DataStream_Content*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  DataStream_Content(InputStream_Content const& stream, ProcessContext const & arg2);
  DataStream_Content(InputStream_Content const& stream);
  ~DataStream_Content() {
    if (swig_owns_self_) {
      inworld_DataStream_Content_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  DataStream_Content(DataStream_Content const & other);
  InputStream_Content stream() const;
  CancellationContext cancellation_context() const;
  bool is_valid() const;

  explicit DataStream_Content(SwigObj_inworld_DataStream_Content* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  DataStream_Content& operator=(DataStream_Content const&) = delete;
  DataStream_Content(DataStream_Content&& obj) = default;
  DataStream_Content& operator=(DataStream_Content&& obj) = default;
  SwigObj_inworld_DataStream_Content* swig_self() const noexcept { return (SwigObj_inworld_DataStream_Content*)BaseData::swig_self(); }
};

class DataStream_AudioChunk : public BaseData {
public:
  static DataStream_AudioChunk null() { return DataStream_AudioChunk{(SwigObj_inworld_DataStream_AudioChunk*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  DataStream_AudioChunk(InputStream_AudioChunk const& stream, ProcessContext const & arg2);
  DataStream_AudioChunk(InputStream_AudioChunk const& stream);
  ~DataStream_AudioChunk() {
    if (swig_owns_self_) {
      inworld_DataStream_AudioChunk_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  DataStream_AudioChunk(DataStream_AudioChunk const & other);
  InputStream_AudioChunk stream() const;
  CancellationContext cancellation_context() const;
  bool is_valid() const;

  explicit DataStream_AudioChunk(SwigObj_inworld_DataStream_AudioChunk* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  DataStream_AudioChunk& operator=(DataStream_AudioChunk const&) = delete;
  DataStream_AudioChunk(DataStream_AudioChunk&& obj) = default;
  DataStream_AudioChunk& operator=(DataStream_AudioChunk&& obj) = default;
  SwigObj_inworld_DataStream_AudioChunk* swig_self() const noexcept { return (SwigObj_inworld_DataStream_AudioChunk*)BaseData::swig_self(); }
};

class DataStream_BaseData : public BaseData {
public:
  static DataStream_BaseData null() { return DataStream_BaseData{(SwigObj_inworld_DataStream_BaseData*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  DataStream_BaseData(InputStream_BaseData const& stream, ProcessContext const & arg2);
  DataStream_BaseData(InputStream_BaseData const& stream);
  ~DataStream_BaseData() {
    if (swig_owns_self_) {
      inworld_DataStream_BaseData_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  DataStream_BaseData(DataStream_BaseData const & other);
  InputStream_BaseData stream() const;
  CancellationContext cancellation_context() const;
  bool is_valid() const;

  explicit DataStream_BaseData(SwigObj_inworld_DataStream_BaseData* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  DataStream_BaseData& operator=(DataStream_BaseData const&) = delete;
  DataStream_BaseData(DataStream_BaseData&& obj) = default;
  DataStream_BaseData& operator=(DataStream_BaseData&& obj) = default;
  SwigObj_inworld_DataStream_BaseData* swig_self() const noexcept { return (SwigObj_inworld_DataStream_BaseData*)BaseData::swig_self(); }
};

class EventHistory : public BaseData {
public:
  static EventHistory null() { return EventHistory{(SwigObj_inworld_EventHistory*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  EventHistory();
  EventHistory(vector_Event const& events);
  vector_Event events() const;
  bool is_valid() const;
  EventHistory(EventHistory const & other);
  ~EventHistory() {
    if (swig_owns_self_) {
      inworld_EventHistory_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit EventHistory(SwigObj_inworld_EventHistory* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  EventHistory& operator=(EventHistory const&) = delete;
  EventHistory(EventHistory&& obj) = default;
  EventHistory& operator=(EventHistory&& obj) = default;
  SwigObj_inworld_EventHistory* swig_self() const noexcept { return (SwigObj_inworld_EventHistory*)BaseData::swig_self(); }
};

class StatusOr_CustomNodeWrapper {
public:
  StatusOr_CustomNodeWrapper();
  StatusOr_CustomNodeWrapper(CustomNodeWrapper const& value);
  StatusOr_CustomNodeWrapper(Status const & status);
  bool ok() const;
  Status status() const;
  CustomNodeWrapper value() const;
  StatusOr_CustomNodeWrapper(StatusOr_CustomNodeWrapper const & other);
  ~StatusOr_CustomNodeWrapper() {
    if (swig_owns_self_)
      inworld_StatusOr_CustomNodeWrapper_delete(swig_self_);
  }

  explicit StatusOr_CustomNodeWrapper(SwigObj_inworld_StatusOr_CustomNodeWrapper* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_CustomNodeWrapper& operator=(StatusOr_CustomNodeWrapper const&) = delete;
  StatusOr_CustomNodeWrapper(StatusOr_CustomNodeWrapper&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_CustomNodeWrapper& operator=(StatusOr_CustomNodeWrapper&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_CustomNodeWrapper_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_CustomNodeWrapper* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_CustomNodeWrapper* swig_self_;
  bool swig_owns_self_;
};

class CustomNodeThreadedCreateExecutor {
public:
  CustomNodeThreadedCreateExecutor(void * context, void * arg2);
  ~CustomNodeThreadedCreateExecutor() {
    if (swig_owns_self_)
      inworld_CustomNodeThreadedCreateExecutor_delete(swig_self_);
  }
  static std::string GetInputId(int execution_id);
  static CreationContext GetInputCreationContext(int execution_id);
  static CustomExecutionConfigWrapper GetInputExecutionConfig(int execution_id);
  static vector_CustomConfigWrapper GetInputConfigs(int execution_id);
  static void SetOutput(int execution_id, StatusOr_CustomNodeWrapper const & arg2);
  CustomNodeThreadedCreateExecutor(CustomNodeThreadedCreateExecutor const & other);

  explicit CustomNodeThreadedCreateExecutor(SwigObj_inworld_CustomNodeThreadedCreateExecutor* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  CustomNodeThreadedCreateExecutor& operator=(CustomNodeThreadedCreateExecutor const&) = delete;
  CustomNodeThreadedCreateExecutor(CustomNodeThreadedCreateExecutor&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  CustomNodeThreadedCreateExecutor& operator=(CustomNodeThreadedCreateExecutor&& obj) noexcept {
    if (swig_owns_self_)
      inworld_CustomNodeThreadedCreateExecutor_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_CustomNodeThreadedCreateExecutor* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_CustomNodeThreadedCreateExecutor* swig_self_;
  bool swig_owns_self_;
};

class HashMap_StringToString {
public:
  HashMap_StringToString();
  ~HashMap_StringToString() {
    if (swig_owns_self_)
      inworld_HashMap_StringToString_delete(swig_self_);
  }
  size_t size() const;
  bool empty() const;
  void clear();
  char * __getitem__(std::string const& key);
  void __setitem__(std::string const& key, std::string const& arg3);
  bool __contains__(std::string const& key);
  HashMap_StringToString(HashMap_StringToString const & other);

  explicit HashMap_StringToString(SwigObj_inworld_HashMap_StringToString* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  HashMap_StringToString& operator=(HashMap_StringToString const&) = delete;
  HashMap_StringToString(HashMap_StringToString&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  HashMap_StringToString& operator=(HashMap_StringToString&& obj) noexcept {
    if (swig_owns_self_)
      inworld_HashMap_StringToString_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_HashMap_StringToString* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_HashMap_StringToString* swig_self_;
  bool swig_owns_self_;
};

class BTreeMap_StringToString {
public:
  BTreeMap_StringToString();
  ~BTreeMap_StringToString() {
    if (swig_owns_self_)
      inworld_BTreeMap_StringToString_delete(swig_self_);
  }
  size_t size() const;
  bool empty() const;
  void clear();
  char * __getitem__(std::string const& key);
  void __setitem__(std::string const& key, std::string const& arg3);
  bool __contains__(std::string const& key);
  BTreeMap_StringToString(BTreeMap_StringToString const & other);

  explicit BTreeMap_StringToString(SwigObj_inworld_BTreeMap_StringToString* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  BTreeMap_StringToString& operator=(BTreeMap_StringToString const&) = delete;
  BTreeMap_StringToString(BTreeMap_StringToString&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  BTreeMap_StringToString& operator=(BTreeMap_StringToString&& obj) noexcept {
    if (swig_owns_self_)
      inworld_BTreeMap_StringToString_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_BTreeMap_StringToString* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_BTreeMap_StringToString* swig_self_;
  bool swig_owns_self_;
};

class HashMap_StringToBaseData {
public:
  HashMap_StringToBaseData();
  ~HashMap_StringToBaseData() {
    if (swig_owns_self_)
      inworld_HashMap_StringToBaseData_delete(swig_self_);
  }
  size_t size() const;
  bool empty() const;
  void clear();
  BaseData __getitem__(std::string const& key);
  void __setitem__(std::string const& key, BaseData const& arg3);
  bool __contains__(std::string const& key);
  HashMap_StringToBaseData(HashMap_StringToBaseData const & other);

  explicit HashMap_StringToBaseData(SwigObj_inworld_HashMap_StringToBaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  HashMap_StringToBaseData& operator=(HashMap_StringToBaseData const&) = delete;
  HashMap_StringToBaseData(HashMap_StringToBaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  HashMap_StringToBaseData& operator=(HashMap_StringToBaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_HashMap_StringToBaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_HashMap_StringToBaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_HashMap_StringToBaseData* swig_self_;
  bool swig_owns_self_;
};

class OptionalHashMapStringToBaseData {
public:
  OptionalHashMapStringToBaseData();
  OptionalHashMapStringToBaseData(HashMap_StringToBaseData const & value);
  OptionalHashMapStringToBaseData(OptionalHashMapStringToBaseData const & other);
  ~OptionalHashMapStringToBaseData() {
    if (swig_owns_self_)
      inworld_OptionalHashMapStringToBaseData_delete(swig_self_);
  }
  bool has_value() const;
  HashMap_StringToBaseData value();
  HashMap_StringToBaseData value() const;
  HashMap_StringToBaseData value_or(HashMap_StringToBaseData const & default_value) const;
  void reset();
  HashMap_StringToBaseData operator *();
  HashMap_StringToBaseData operator *() const;
  HashMap_StringToBaseData get_value();
  void set_value(HashMap_StringToBaseData & t);

  explicit OptionalHashMapStringToBaseData(SwigObj_inworld_OptionalHashMapStringToBaseData* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  OptionalHashMapStringToBaseData& operator=(OptionalHashMapStringToBaseData const&) = delete;
  OptionalHashMapStringToBaseData(OptionalHashMapStringToBaseData&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  OptionalHashMapStringToBaseData& operator=(OptionalHashMapStringToBaseData&& obj) noexcept {
    if (swig_owns_self_)
      inworld_OptionalHashMapStringToBaseData_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_OptionalHashMapStringToBaseData* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_OptionalHashMapStringToBaseData* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_ResultItem {
public:
  StatusOr_ResultItem();
  StatusOr_ResultItem(ResultItem const & value);
  StatusOr_ResultItem(Status const & status);
  bool ok() const;
  Status status() const;
  ResultItem value() const;
  StatusOr_ResultItem(StatusOr_ResultItem const & other);
  ~StatusOr_ResultItem() {
    if (swig_owns_self_)
      inworld_StatusOr_ResultItem_delete(swig_self_);
  }

  explicit StatusOr_ResultItem(SwigObj_inworld_StatusOr_ResultItem* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_ResultItem& operator=(StatusOr_ResultItem const&) = delete;
  StatusOr_ResultItem(StatusOr_ResultItem&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_ResultItem& operator=(StatusOr_ResultItem&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_ResultItem_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_ResultItem* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_ResultItem* swig_self_;
  bool swig_owns_self_;
};

class InputStream_ResultItem {
public:
  static InputStream_ResultItem null() { return InputStream_ResultItem{(SwigObj_inworld_InputStream_ResultItem*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~InputStream_ResultItem() {
    if (swig_owns_self_)
      inworld_InputStream_ResultItem_delete(swig_self_);
  }
  virtual bool HasNext();
  virtual StatusOr_ResultItem Read();
  virtual void Cancel();
  bool is_valid() const;

  explicit InputStream_ResultItem(SwigObj_inworld_InputStream_ResultItem* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  InputStream_ResultItem(InputStream_ResultItem const&) = delete;
  InputStream_ResultItem& operator=(InputStream_ResultItem const&) = delete;
  InputStream_ResultItem(InputStream_ResultItem&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  InputStream_ResultItem& operator=(InputStream_ResultItem&& obj) noexcept {
    if (swig_owns_self_)
      inworld_InputStream_ResultItem_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_InputStream_ResultItem* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_InputStream_ResultItem* swig_self_;
  bool swig_owns_self_;
};

class ResultItem {
public:
  static ResultItem null() { return ResultItem{(SwigObj_inworld_ResultItem*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ResultItem(BaseData const& value, optional_string const& arg2);
  ResultItem(BaseData const& value);
  void value(BaseData const& value);
  BaseData value() const;
  void node_id(optional_string * node_id);
  optional_string * node_id() const;
  BaseData safe_value() const;
  ResultItem(ResultItem const & other);
  ~ResultItem() {
    if (swig_owns_self_)
      inworld_ResultItem_delete(swig_self_);
  }

  explicit ResultItem(SwigObj_inworld_ResultItem* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ResultItem& operator=(ResultItem const&) = delete;
  ResultItem(ResultItem&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ResultItem& operator=(ResultItem&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ResultItem_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ResultItem* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ResultItem* swig_self_;
  bool swig_owns_self_;
};

class ExecutionResult {
public:
  static ExecutionResult CreateEmpty(std::string const& variant, std::string const& arg2);
  static ExecutionResult CreateEmpty(std::string const& variant);
  static ExecutionResult CreateEmpty();
  static ExecutionResult CreateWithError(Status const & error_status, std::string const& arg2, std::string const& arg3);
  ~ExecutionResult() {
    if (swig_owns_self_)
      inworld_ExecutionResult_delete(swig_self_);
  }
  void Cancel();
  InputStream_ResultItem GetResultStream() const;
  std::string GetVariant() const;
  std::string GetExecutionId() const;

  explicit ExecutionResult(SwigObj_inworld_ExecutionResult* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ExecutionResult(ExecutionResult const&) = delete;
  ExecutionResult& operator=(ExecutionResult const&) = delete;
  ExecutionResult(ExecutionResult&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ExecutionResult& operator=(ExecutionResult&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ExecutionResult_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ExecutionResult* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ExecutionResult* swig_self_;
  bool swig_owns_self_;
};

class UserContext {
public:
  void attributes(BTreeMap_StringToString * attributes);
  BTreeMap_StringToString * attributes() const;
  void targeting_key(std::string const& targeting_key);
  std::string targeting_key() const;
  UserContext();
  UserContext(UserContext const & other);
  ~UserContext() {
    if (swig_owns_self_)
      inworld_UserContext_delete(swig_self_);
  }

  explicit UserContext(SwigObj_inworld_UserContext* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  UserContext& operator=(UserContext const&) = delete;
  UserContext(UserContext&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  UserContext& operator=(UserContext&& obj) noexcept {
    if (swig_owns_self_)
      inworld_UserContext_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_UserContext* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_UserContext* swig_self_;
  bool swig_owns_self_;
};

class ExecutionContext {
public:
  void execution_id(optional_string * execution_id);
  optional_string * execution_id() const;
  void user_context(optional_UserContext * user_context);
  optional_UserContext * user_context() const;
  void data_to_store(OptionalHashMapStringToBaseData * data_to_store);
  OptionalHashMapStringToBaseData * data_to_store() const;
  static ExecutionContext Empty();
  ExecutionContext();
  ExecutionContext(ExecutionContext const & other);
  ~ExecutionContext() {
    if (swig_owns_self_)
      inworld_ExecutionContext_delete(swig_self_);
  }

  explicit ExecutionContext(SwigObj_inworld_ExecutionContext* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ExecutionContext& operator=(ExecutionContext const&) = delete;
  ExecutionContext(ExecutionContext&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ExecutionContext& operator=(ExecutionContext&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ExecutionContext_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ExecutionContext* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ExecutionContext* swig_self_;
  bool swig_owns_self_;
};

class ExecutorInterface {
public:
  virtual ~ExecutorInterface() {
    if (swig_owns_self_)
      inworld_ExecutorInterface_delete(swig_self_);
  }
  virtual Status Start();
  virtual ExecutionResult Execute(BaseData const& input, ExecutionContext const & arg3);
  virtual ExecutionResult Execute(BaseData const& input);
  virtual Status Stop();

  explicit ExecutorInterface(SwigObj_inworld_ExecutorInterface* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ExecutorInterface(ExecutorInterface const&) = delete;
  ExecutorInterface& operator=(ExecutorInterface const&) = delete;
  ExecutorInterface(ExecutorInterface&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ExecutorInterface& operator=(ExecutorInterface&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ExecutorInterface_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ExecutorInterface* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ExecutorInterface* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_ExecutorInterfacePtr {
public:
  StatusOr_ExecutorInterfacePtr();
  StatusOr_ExecutorInterfacePtr(ExecutorInterface * value);
  StatusOr_ExecutorInterfacePtr(Status const & status);
  bool ok() const;
  Status status() const;
  ExecutorInterface * value() const;
  StatusOr_ExecutorInterfacePtr(StatusOr_ExecutorInterfacePtr const & other);
  ~StatusOr_ExecutorInterfacePtr() {
    if (swig_owns_self_)
      inworld_StatusOr_ExecutorInterfacePtr_delete(swig_self_);
  }

  explicit StatusOr_ExecutorInterfacePtr(SwigObj_inworld_StatusOr_ExecutorInterfacePtr* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_ExecutorInterfacePtr& operator=(StatusOr_ExecutorInterfacePtr const&) = delete;
  StatusOr_ExecutorInterfacePtr(StatusOr_ExecutorInterfacePtr&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_ExecutorInterfacePtr& operator=(StatusOr_ExecutorInterfacePtr&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_ExecutorInterfacePtr_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_ExecutorInterfacePtr* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_ExecutorInterfacePtr* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_GraphExecutorFactoryPtr {
public:
  StatusOr_GraphExecutorFactoryPtr();
  StatusOr_GraphExecutorFactoryPtr(GraphExecutorFactory * value);
  StatusOr_GraphExecutorFactoryPtr(Status const & status);
  bool ok() const;
  Status status() const;
  GraphExecutorFactory * value() const;
  StatusOr_GraphExecutorFactoryPtr(StatusOr_GraphExecutorFactoryPtr const & other);
  ~StatusOr_GraphExecutorFactoryPtr() {
    if (swig_owns_self_)
      inworld_StatusOr_GraphExecutorFactoryPtr_delete(swig_self_);
  }

  explicit StatusOr_GraphExecutorFactoryPtr(SwigObj_inworld_StatusOr_GraphExecutorFactoryPtr* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_GraphExecutorFactoryPtr& operator=(StatusOr_GraphExecutorFactoryPtr const&) = delete;
  StatusOr_GraphExecutorFactoryPtr(StatusOr_GraphExecutorFactoryPtr&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_GraphExecutorFactoryPtr& operator=(StatusOr_GraphExecutorFactoryPtr&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_GraphExecutorFactoryPtr_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_GraphExecutorFactoryPtr* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_GraphExecutorFactoryPtr* swig_self_;
  bool swig_owns_self_;
};

class Optional_ThreadPoolConfig {
public:
  Optional_ThreadPoolConfig();
  Optional_ThreadPoolConfig(ThreadPoolConfig const & value);
  Optional_ThreadPoolConfig(Optional_ThreadPoolConfig const & other);
  ~Optional_ThreadPoolConfig() {
    if (swig_owns_self_)
      inworld_Optional_ThreadPoolConfig_delete(swig_self_);
  }
  bool has_value() const;
  ThreadPoolConfig value();
  ThreadPoolConfig value() const;
  ThreadPoolConfig value_or(ThreadPoolConfig const & default_value) const;
  void reset();
  ThreadPoolConfig operator *();
  ThreadPoolConfig operator *() const;
  ThreadPoolConfig get_value();
  void set_value(ThreadPoolConfig & t);

  explicit Optional_ThreadPoolConfig(SwigObj_inworld_Optional_ThreadPoolConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Optional_ThreadPoolConfig& operator=(Optional_ThreadPoolConfig const&) = delete;
  Optional_ThreadPoolConfig(Optional_ThreadPoolConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Optional_ThreadPoolConfig& operator=(Optional_ThreadPoolConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Optional_ThreadPoolConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Optional_ThreadPoolConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Optional_ThreadPoolConfig* swig_self_;
  bool swig_owns_self_;
};

class GraphManagerConfig {
public:
  enum class EvaluationMode  {
    IN_PROCESS_ONLY,
    REMOTE_ONLY
  };

  void enable_remote_config(bool enable_remote_config);
  bool enable_remote_config() const;
  void poll_interval(Duration * poll_interval);
  Duration * poll_interval() const;
  void address(std::string const& address);
  std::string address() const;
  void inworld_api_key(std::string const& inworld_api_key);
  std::string inworld_api_key() const;
  void evaluation_mode(GraphManagerConfig::EvaluationMode evaluation_mode);
  GraphManagerConfig::EvaluationMode evaluation_mode() const;
  void config_environment_variables(HashMap_StringToString * config_environment_variables);
  HashMap_StringToString * config_environment_variables() const;
  static GraphManagerConfig Default();
  static GraphManagerConfig WithDisabledRemoteConfig();
  static GraphManagerConfig WithRemoteConfig(std::string const& address, std::string const& arg2, Duration const& arg3, GraphManagerConfig::EvaluationMode arg4);
  static GraphManagerConfig WithRemoteConfig(std::string const& address, std::string const& arg2, Duration const& arg3);
  static GraphManagerConfig WithRemoteConfig(std::string const& address, std::string const& arg2);
  GraphManagerConfig();
  GraphManagerConfig(GraphManagerConfig const & other);
  ~GraphManagerConfig() {
    if (swig_owns_self_)
      inworld_GraphManagerConfig_delete(swig_self_);
  }

  explicit GraphManagerConfig(SwigObj_inworld_GraphManagerConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  GraphManagerConfig& operator=(GraphManagerConfig const&) = delete;
  GraphManagerConfig(GraphManagerConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  GraphManagerConfig& operator=(GraphManagerConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_GraphManagerConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_GraphManagerConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_GraphManagerConfig* swig_self_;
  bool swig_owns_self_;
};

class ThreadPoolConfig {
public:
  enum class WorkerCountStrategy  {
    FIXED,
    SYSTEM_CORES
  };

  enum class ThreadPoolStrategy  {
    DEDICATED,
    SHARED
  };

  void worker_strategy(ThreadPoolConfig::WorkerCountStrategy worker_strategy);
  ThreadPoolConfig::WorkerCountStrategy worker_strategy() const;
  void thread_pool_strategy(ThreadPoolConfig::ThreadPoolStrategy thread_pool_strategy);
  ThreadPoolConfig::ThreadPoolStrategy thread_pool_strategy() const;
  void worker_count(optional_sizet * worker_count);
  optional_sizet * worker_count() const;
  void core_multiplier(float core_multiplier);
  float core_multiplier() const;
  static ThreadPoolConfig Default();
  static ThreadPoolConfig WithFixedWorkers(size_t worker_count);
  static ThreadPoolConfig WithSystemCores(float multiplier);
  static ThreadPoolConfig WithSystemCores();
  ThreadPoolConfig();
  ThreadPoolConfig(ThreadPoolConfig const & other);
  ~ThreadPoolConfig() {
    if (swig_owns_self_)
      inworld_ThreadPoolConfig_delete(swig_self_);
  }

  explicit ThreadPoolConfig(SwigObj_inworld_ThreadPoolConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ThreadPoolConfig& operator=(ThreadPoolConfig const&) = delete;
  ThreadPoolConfig(ThreadPoolConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ThreadPoolConfig& operator=(ThreadPoolConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ThreadPoolConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ThreadPoolConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ThreadPoolConfig* swig_self_;
  bool swig_owns_self_;
};

class GraphExecutorFactoryConfig {
public:
  void thread_pool_strategy(ThreadPoolConfig::ThreadPoolStrategy thread_pool_strategy);
  ThreadPoolConfig::ThreadPoolStrategy thread_pool_strategy() const;
  void thread_pool_config(ThreadPoolConfig * thread_pool_config);
  ThreadPoolConfig * thread_pool_config() const;
  static GraphExecutorFactoryConfig Default();
  static GraphExecutorFactoryConfig WithSharedThreadPool(ThreadPoolConfig const & thread_pool_config);
  static GraphExecutorFactoryConfig WithDedicatedThreadPool(ThreadPoolConfig const & thread_pool_config);
  GraphExecutorFactoryConfig();
  GraphExecutorFactoryConfig(GraphExecutorFactoryConfig const & other);
  ~GraphExecutorFactoryConfig() {
    if (swig_owns_self_)
      inworld_GraphExecutorFactoryConfig_delete(swig_self_);
  }

  explicit GraphExecutorFactoryConfig(SwigObj_inworld_GraphExecutorFactoryConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  GraphExecutorFactoryConfig& operator=(GraphExecutorFactoryConfig const&) = delete;
  GraphExecutorFactoryConfig(GraphExecutorFactoryConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  GraphExecutorFactoryConfig& operator=(GraphExecutorFactoryConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_GraphExecutorFactoryConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_GraphExecutorFactoryConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_GraphExecutorFactoryConfig* swig_self_;
  bool swig_owns_self_;
};

class GraphExecutorConfig {
public:
  void graph_manager_config(GraphManagerConfig * graph_manager_config);
  GraphManagerConfig * graph_manager_config() const;
  void thread_pool_config_override(Optional_ThreadPoolConfig * thread_pool_config_override);
  Optional_ThreadPoolConfig * thread_pool_config_override() const;
  static GraphExecutorConfig Default();
  static GraphExecutorConfig WithGraphManager(GraphManagerConfig const & graph_manager_config);
  static GraphExecutorConfig WithLocalGraphManager();
  GraphExecutorConfig();
  GraphExecutorConfig(GraphExecutorConfig const & other);
  ~GraphExecutorConfig() {
    if (swig_owns_self_)
      inworld_GraphExecutorConfig_delete(swig_self_);
  }

  explicit GraphExecutorConfig(SwigObj_inworld_GraphExecutorConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  GraphExecutorConfig& operator=(GraphExecutorConfig const&) = delete;
  GraphExecutorConfig(GraphExecutorConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  GraphExecutorConfig& operator=(GraphExecutorConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_GraphExecutorConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_GraphExecutorConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_GraphExecutorConfig* swig_self_;
  bool swig_owns_self_;
};

class GraphExecutorFactory {
public:
  ~GraphExecutorFactory() {
    if (swig_owns_self_)
      inworld_GraphExecutorFactory_delete(swig_self_);
  }
  static StatusOr_GraphExecutorFactoryPtr inworld_inworld_graphs_GraphExecutorFactory_CreateHelper__SWIG_0();
  static StatusOr_GraphExecutorFactoryPtr inworld_inworld_graphs_GraphExecutorFactory_CreateHelper__SWIG_1(GraphExecutorFactoryConfig const & config);
  StatusOr_ExecutorInterfacePtr CreateExecutorHelper(CompiledGraphInterface * graphs);
  StatusOr_ExecutorInterfacePtr CreateExecutorHelper(CompiledGraphInterface * graphs, GraphExecutorConfig const & arg3);

  explicit GraphExecutorFactory(SwigObj_inworld_GraphExecutorFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  GraphExecutorFactory(GraphExecutorFactory const&) = delete;
  GraphExecutorFactory& operator=(GraphExecutorFactory const&) = delete;
  GraphExecutorFactory(GraphExecutorFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  GraphExecutorFactory& operator=(GraphExecutorFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_GraphExecutorFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_GraphExecutorFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_GraphExecutorFactory* swig_self_;
  bool swig_owns_self_;
};

class FeedbackRecorder {
public:
  static void RecordFeedback(std::string const& graph_id, std::string const& arg2, std::string const& arg3, std::string const& arg4);
  FeedbackRecorder(FeedbackRecorder const & other);

  explicit FeedbackRecorder(SwigObj_inworld_FeedbackRecorder* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  FeedbackRecorder& operator=(FeedbackRecorder const&) = delete;
  FeedbackRecorder(FeedbackRecorder&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  FeedbackRecorder& operator=(FeedbackRecorder&& obj) noexcept {
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_FeedbackRecorder* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_FeedbackRecorder* swig_self_;
  bool swig_owns_self_;
};

class MCPHttpAuthConfig {
public:
  void api_key(std::string const& api_key);
  std::string api_key() const;
  MCPHttpAuthConfig();
  MCPHttpAuthConfig(MCPHttpAuthConfig const & other);
  ~MCPHttpAuthConfig() {
    if (swig_owns_self_)
      inworld_MCPHttpAuthConfig_delete(swig_self_);
  }

  explicit MCPHttpAuthConfig(SwigObj_inworld_MCPHttpAuthConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MCPHttpAuthConfig& operator=(MCPHttpAuthConfig const&) = delete;
  MCPHttpAuthConfig(MCPHttpAuthConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MCPHttpAuthConfig& operator=(MCPHttpAuthConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MCPHttpAuthConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MCPHttpAuthConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MCPHttpAuthConfig* swig_self_;
  bool swig_owns_self_;
};

class ParagonApiAuthConfig {
public:
  void jwt_token(std::string const& jwt_token);
  std::string jwt_token() const;
  ParagonApiAuthConfig();
  ParagonApiAuthConfig(ParagonApiAuthConfig const & other);
  ~ParagonApiAuthConfig() {
    if (swig_owns_self_)
      inworld_ParagonApiAuthConfig_delete(swig_self_);
  }

  explicit ParagonApiAuthConfig(SwigObj_inworld_ParagonApiAuthConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ParagonApiAuthConfig& operator=(ParagonApiAuthConfig const&) = delete;
  ParagonApiAuthConfig(ParagonApiAuthConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ParagonApiAuthConfig& operator=(ParagonApiAuthConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ParagonApiAuthConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ParagonApiAuthConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ParagonApiAuthConfig* swig_self_;
  bool swig_owns_self_;
};

class MCPStdioAuthConfig {
public:
  void set(std::string const& key, std::string const& arg3);
  MCPStdioAuthConfig();
  MCPStdioAuthConfig(MCPStdioAuthConfig const & other);
  ~MCPStdioAuthConfig() {
    if (swig_owns_self_)
      inworld_MCPStdioAuthConfig_delete(swig_self_);
  }

  explicit MCPStdioAuthConfig(SwigObj_inworld_MCPStdioAuthConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MCPStdioAuthConfig& operator=(MCPStdioAuthConfig const&) = delete;
  MCPStdioAuthConfig(MCPStdioAuthConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MCPStdioAuthConfig& operator=(MCPStdioAuthConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MCPStdioAuthConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MCPStdioAuthConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MCPStdioAuthConfig* swig_self_;
  bool swig_owns_self_;
};

class MCPAuthConfig {
public:
  void set_http_auth_config(MCPHttpAuthConfig const & config);
  void set_stdio_auth_config(MCPStdioAuthConfig const & config);
  void set_paragon_api_auth_config(ParagonApiAuthConfig const & config);
  MCPAuthConfig();
  MCPAuthConfig(MCPAuthConfig const & other);
  ~MCPAuthConfig() {
    if (swig_owns_self_)
      inworld_MCPAuthConfig_delete(swig_self_);
  }

  explicit MCPAuthConfig(SwigObj_inworld_MCPAuthConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MCPAuthConfig& operator=(MCPAuthConfig const&) = delete;
  MCPAuthConfig(MCPAuthConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MCPAuthConfig& operator=(MCPAuthConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MCPAuthConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MCPAuthConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MCPAuthConfig* swig_self_;
  bool swig_owns_self_;
};

class MCPSessionCreationConfig {
public:
  void transport(std::string const& transport);
  std::string transport() const;
  void endpoint(std::string const& endpoint);
  std::string endpoint() const;
  void auth_config(MCPAuthConfig * auth_config);
  MCPAuthConfig * auth_config() const;
  MCPSessionCreationConfig();
  MCPSessionCreationConfig(MCPSessionCreationConfig const & other);
  ~MCPSessionCreationConfig() {
    if (swig_owns_self_)
      inworld_MCPSessionCreationConfig_delete(swig_self_);
  }

  explicit MCPSessionCreationConfig(SwigObj_inworld_MCPSessionCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MCPSessionCreationConfig& operator=(MCPSessionCreationConfig const&) = delete;
  MCPSessionCreationConfig(MCPSessionCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MCPSessionCreationConfig& operator=(MCPSessionCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MCPSessionCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MCPSessionCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MCPSessionCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class MCPClientCreationConfig {
public:
  void session_config(MCPSessionCreationConfig * session_config);
  MCPSessionCreationConfig * session_config() const;
  MCPClientCreationConfig();
  MCPClientCreationConfig(MCPClientCreationConfig const & other);
  ~MCPClientCreationConfig() {
    if (swig_owns_self_)
      inworld_MCPClientCreationConfig_delete(swig_self_);
  }

  explicit MCPClientCreationConfig(SwigObj_inworld_MCPClientCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MCPClientCreationConfig& operator=(MCPClientCreationConfig const&) = delete;
  MCPClientCreationConfig(MCPClientCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MCPClientCreationConfig& operator=(MCPClientCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MCPClientCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MCPClientCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MCPClientCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class MCPClientFactory {
public:
  virtual ~MCPClientFactory() {
    if (swig_owns_self_)
      inworld_MCPClientFactory_delete(swig_self_);
  }
  StatusOr_MCPClientInterface CreateMCPClient(MCPClientCreationConfig const & config);
  MCPClientFactory();
  MCPClientFactory(MCPClientFactory const & other);

  explicit MCPClientFactory(SwigObj_inworld_MCPClientFactory* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MCPClientFactory& operator=(MCPClientFactory const&) = delete;
  MCPClientFactory(MCPClientFactory&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MCPClientFactory& operator=(MCPClientFactory&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MCPClientFactory_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MCPClientFactory* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MCPClientFactory* swig_self_;
  bool swig_owns_self_;
};

class TypedNode_MatchedPhrases : public TypedNodeBase {
public:
  static TypedNode_MatchedPhrases null() { return TypedNode_MatchedPhrases{(SwigObj_inworld_TypedNode_MatchedPhrases*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_MatchedPhrases() {
    if (swig_owns_self_) {
      inworld_TypedNode_MatchedPhrases_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_MatchedPhrases(SwigObj_inworld_TypedNode_MatchedPhrases* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_MatchedPhrases(TypedNode_MatchedPhrases const&) = delete;
  TypedNode_MatchedPhrases& operator=(TypedNode_MatchedPhrases const&) = delete;
  TypedNode_MatchedPhrases(TypedNode_MatchedPhrases&& obj) = default;
  TypedNode_MatchedPhrases& operator=(TypedNode_MatchedPhrases&& obj) = default;
  SwigObj_inworld_TypedNode_MatchedPhrases* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_MatchedPhrases*)TypedNodeBase::swig_self(); }
};

class StatusOr_SharedPtr_EmbeddingMatcherNode {
public:
  StatusOr_SharedPtr_EmbeddingMatcherNode();
  StatusOr_SharedPtr_EmbeddingMatcherNode(EmbeddingMatcherNode const& value);
  StatusOr_SharedPtr_EmbeddingMatcherNode(Status const & status);
  bool ok() const;
  Status status() const;
  EmbeddingMatcherNode value() const;
  StatusOr_SharedPtr_EmbeddingMatcherNode(StatusOr_SharedPtr_EmbeddingMatcherNode const & other);
  ~StatusOr_SharedPtr_EmbeddingMatcherNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_EmbeddingMatcherNode(SwigObj_inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_EmbeddingMatcherNode& operator=(StatusOr_SharedPtr_EmbeddingMatcherNode const&) = delete;
  StatusOr_SharedPtr_EmbeddingMatcherNode(StatusOr_SharedPtr_EmbeddingMatcherNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_EmbeddingMatcherNode& operator=(StatusOr_SharedPtr_EmbeddingMatcherNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_EmbeddingMatcherNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_MatchedPhrases {
public:
  StatusOr_SharedPtr_MatchedPhrases();
  StatusOr_SharedPtr_MatchedPhrases(MatchedPhrases const& value);
  StatusOr_SharedPtr_MatchedPhrases(Status const & status);
  bool ok() const;
  Status status() const;
  MatchedPhrases value() const;
  StatusOr_SharedPtr_MatchedPhrases(StatusOr_SharedPtr_MatchedPhrases const & other);
  ~StatusOr_SharedPtr_MatchedPhrases() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MatchedPhrases_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_MatchedPhrases(SwigObj_inworld_StatusOr_SharedPtr_MatchedPhrases* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_MatchedPhrases& operator=(StatusOr_SharedPtr_MatchedPhrases const&) = delete;
  StatusOr_SharedPtr_MatchedPhrases(StatusOr_SharedPtr_MatchedPhrases&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_MatchedPhrases& operator=(StatusOr_SharedPtr_MatchedPhrases&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MatchedPhrases_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_MatchedPhrases* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_MatchedPhrases* swig_self_;
  bool swig_owns_self_;
};

class EmbeddingMatcherNodeCreationConfig {
public:
  void phrases(vector_string * phrases);
  vector_string * phrases() const;
  void embedder_component_id(std::string const& embedder_component_id);
  std::string embedder_component_id() const;
  EmbeddingMatcherNodeCreationConfig();
  EmbeddingMatcherNodeCreationConfig(EmbeddingMatcherNodeCreationConfig const & other);
  ~EmbeddingMatcherNodeCreationConfig() {
    if (swig_owns_self_)
      inworld_EmbeddingMatcherNodeCreationConfig_delete(swig_self_);
  }

  explicit EmbeddingMatcherNodeCreationConfig(SwigObj_inworld_EmbeddingMatcherNodeCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  EmbeddingMatcherNodeCreationConfig& operator=(EmbeddingMatcherNodeCreationConfig const&) = delete;
  EmbeddingMatcherNodeCreationConfig(EmbeddingMatcherNodeCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  EmbeddingMatcherNodeCreationConfig& operator=(EmbeddingMatcherNodeCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_EmbeddingMatcherNodeCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_EmbeddingMatcherNodeCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_EmbeddingMatcherNodeCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class EmbeddingMatcherNodeExecutionConfig : public NodeExecutionConfig {
public:
  static EmbeddingMatcherNodeExecutionConfig null() { return EmbeddingMatcherNodeExecutionConfig{(SwigObj_inworld_EmbeddingMatcherNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void similarity_threshold(float similarity_threshold);
  float similarity_threshold() const;
  void top_n(size_t top_n);
  size_t top_n() const;
  bool is_valid() const;
  EmbeddingMatcherNodeExecutionConfig();
  EmbeddingMatcherNodeExecutionConfig(EmbeddingMatcherNodeExecutionConfig const & other);
  ~EmbeddingMatcherNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_EmbeddingMatcherNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit EmbeddingMatcherNodeExecutionConfig(SwigObj_inworld_EmbeddingMatcherNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  EmbeddingMatcherNodeExecutionConfig& operator=(EmbeddingMatcherNodeExecutionConfig const&) = delete;
  EmbeddingMatcherNodeExecutionConfig(EmbeddingMatcherNodeExecutionConfig&& obj) = default;
  EmbeddingMatcherNodeExecutionConfig& operator=(EmbeddingMatcherNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_EmbeddingMatcherNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_EmbeddingMatcherNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class EmbeddingMatcherNode : public TypedNode_MatchedPhrases {
public:
  static EmbeddingMatcherNode null() { return EmbeddingMatcherNode{(SwigObj_inworld_EmbeddingMatcherNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  static StatusOr_SharedPtr_EmbeddingMatcherNode Create(std::string const& id, CreationContext const & arg2, EmbeddingMatcherNodeCreationConfig const & arg3, EmbeddingMatcherNodeExecutionConfig const & arg4);
  bool is_valid() const;
  EmbeddingMatcherNode(EmbeddingMatcherNode const & other);
  ~EmbeddingMatcherNode() {
    if (swig_owns_self_) {
      inworld_EmbeddingMatcherNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit EmbeddingMatcherNode(SwigObj_inworld_EmbeddingMatcherNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_MatchedPhrases{(SwigObj_inworld_TypedNode_MatchedPhrases*)swig_self, swig_owns_self} {}
  EmbeddingMatcherNode& operator=(EmbeddingMatcherNode const&) = delete;
  EmbeddingMatcherNode(EmbeddingMatcherNode&& obj) = default;
  EmbeddingMatcherNode& operator=(EmbeddingMatcherNode&& obj) = default;
  SwigObj_inworld_EmbeddingMatcherNode* swig_self() const noexcept { return (SwigObj_inworld_EmbeddingMatcherNode*)TypedNode_MatchedPhrases::swig_self(); }
};

class optional_Condition {
public:
  optional_Condition();
  optional_Condition(Condition const & value);
  optional_Condition(optional_Condition const & other);
  ~optional_Condition() {
    if (swig_owns_self_)
      inworld_optional_Condition_delete(swig_self_);
  }
  bool has_value() const;
  Condition value();
  Condition value() const;
  Condition value_or(Condition const & default_value) const;
  void reset();
  Condition operator *();
  Condition operator *() const;
  Condition get_value();
  void set_value(Condition & t);

  explicit optional_Condition(SwigObj_inworld_optional_Condition* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_Condition& operator=(optional_Condition const&) = delete;
  optional_Condition(optional_Condition&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_Condition& operator=(optional_Condition&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_Condition_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_Condition* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_Condition* swig_self_;
  bool swig_owns_self_;
};

class Condition {
public:
  void intents(vector_string * intents);
  vector_string * intents() const;
  void detect(optional_string * detect);
  optional_string * detect() const;
  void required_goals(vector_string * required_goals);
  vector_string * required_goals() const;
  Condition();
  Condition(Condition const & other);
  ~Condition() {
    if (swig_owns_self_)
      inworld_Condition_delete(swig_self_);
  }

  explicit Condition(SwigObj_inworld_Condition* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Condition& operator=(Condition const&) = delete;
  Condition(Condition&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Condition& operator=(Condition&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Condition_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Condition* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Condition* swig_self_;
  bool swig_owns_self_;
};

class Goal {
public:
  void name(std::string const& name);
  std::string name() const;
  void motivation(optional_string * motivation);
  optional_string * motivation() const;
  void repeatable(bool repeatable);
  bool repeatable() const;
  void activation_condition(optional_Condition * activation_condition);
  optional_Condition * activation_condition() const;
  void completion_condition(optional_Condition * completion_condition);
  optional_Condition * completion_condition() const;
  Goal();
  Goal(Goal const & other);
  ~Goal() {
    if (swig_owns_self_)
      inworld_Goal_delete(swig_self_);
  }

  explicit Goal(SwigObj_inworld_Goal* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  Goal& operator=(Goal const&) = delete;
  Goal(Goal&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  Goal& operator=(Goal&& obj) noexcept {
    if (swig_owns_self_)
      inworld_Goal_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_Goal* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_Goal* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_GoalAdvancementNode {
public:
  StatusOr_SharedPtr_GoalAdvancementNode();
  StatusOr_SharedPtr_GoalAdvancementNode(GoalAdvancementNode const& value);
  StatusOr_SharedPtr_GoalAdvancementNode(Status const & status);
  bool ok() const;
  Status status() const;
  GoalAdvancementNode value() const;
  StatusOr_SharedPtr_GoalAdvancementNode(StatusOr_SharedPtr_GoalAdvancementNode const & other);
  ~StatusOr_SharedPtr_GoalAdvancementNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_GoalAdvancementNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_GoalAdvancementNode(SwigObj_inworld_StatusOr_SharedPtr_GoalAdvancementNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_GoalAdvancementNode& operator=(StatusOr_SharedPtr_GoalAdvancementNode const&) = delete;
  StatusOr_SharedPtr_GoalAdvancementNode(StatusOr_SharedPtr_GoalAdvancementNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_GoalAdvancementNode& operator=(StatusOr_SharedPtr_GoalAdvancementNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_GoalAdvancementNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_GoalAdvancementNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_GoalAdvancementNode* swig_self_;
  bool swig_owns_self_;
};

class vector_Goal {
public:
  vector_Goal();
  vector_Goal(vector_Goal const & other);
  size_t size() const;
  size_t capacity() const;
  void reserve(size_t n);
  bool empty() const;
  void clear();
  void push_back(Goal const & x);
  Goal get(int i);
  void set(int i, Goal const & arg3);
  ~vector_Goal() {
    if (swig_owns_self_)
      inworld_vector_Goal_delete(swig_self_);
  }

  explicit vector_Goal(SwigObj_inworld_vector_Goal* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  vector_Goal& operator=(vector_Goal const&) = delete;
  vector_Goal(vector_Goal&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  vector_Goal& operator=(vector_Goal&& obj) noexcept {
    if (swig_owns_self_)
      inworld_vector_Goal_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_vector_Goal* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_vector_Goal* swig_self_;
  bool swig_owns_self_;
};

class GoalAdvancementNodeCreationConfig {
public:
  void goals(vector_Goal * goals);
  vector_Goal * goals() const;
  GoalAdvancementNodeCreationConfig();
  GoalAdvancementNodeCreationConfig(GoalAdvancementNodeCreationConfig const & other);
  ~GoalAdvancementNodeCreationConfig() {
    if (swig_owns_self_)
      inworld_GoalAdvancementNodeCreationConfig_delete(swig_self_);
  }

  explicit GoalAdvancementNodeCreationConfig(SwigObj_inworld_GoalAdvancementNodeCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  GoalAdvancementNodeCreationConfig& operator=(GoalAdvancementNodeCreationConfig const&) = delete;
  GoalAdvancementNodeCreationConfig(GoalAdvancementNodeCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  GoalAdvancementNodeCreationConfig& operator=(GoalAdvancementNodeCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_GoalAdvancementNodeCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_GoalAdvancementNodeCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_GoalAdvancementNodeCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class GoalAdvancementNodeExecutionConfig : public NodeExecutionConfig {
public:
  static GoalAdvancementNodeExecutionConfig null() { return GoalAdvancementNodeExecutionConfig{(SwigObj_inworld_GoalAdvancementNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void llm_component_id(std::string const& llm_component_id);
  std::string llm_component_id() const;
  void text_generation_config(optional_TextGenerationConfig * text_generation_config);
  optional_TextGenerationConfig * text_generation_config() const;
  bool is_valid() const;
  GoalAdvancementNodeExecutionConfig();
  GoalAdvancementNodeExecutionConfig(GoalAdvancementNodeExecutionConfig const & other);
  ~GoalAdvancementNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_GoalAdvancementNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit GoalAdvancementNodeExecutionConfig(SwigObj_inworld_GoalAdvancementNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  GoalAdvancementNodeExecutionConfig& operator=(GoalAdvancementNodeExecutionConfig const&) = delete;
  GoalAdvancementNodeExecutionConfig(GoalAdvancementNodeExecutionConfig&& obj) = default;
  GoalAdvancementNodeExecutionConfig& operator=(GoalAdvancementNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_GoalAdvancementNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_GoalAdvancementNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class GoalAdvancementNode : public TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text {
public:
  static GoalAdvancementNode null() { return GoalAdvancementNode{(SwigObj_inworld_GoalAdvancementNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_GoalAdvancementNode inworld_inworld_graphs_GoalAdvancementNode_Create__SWIG(std::string const& id, GoalAdvancementNodeCreationConfig const & arg2, GoalAdvancementNodeExecutionConfig const& arg3);
  ~GoalAdvancementNode() {
    if (swig_owns_self_) {
      inworld_GoalAdvancementNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit GoalAdvancementNode(SwigObj_inworld_GoalAdvancementNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text{(SwigObj_inworld_TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text*)swig_self, swig_owns_self} {}
  GoalAdvancementNode(GoalAdvancementNode const&) = delete;
  GoalAdvancementNode& operator=(GoalAdvancementNode const&) = delete;
  GoalAdvancementNode(GoalAdvancementNode&& obj) = default;
  GoalAdvancementNode& operator=(GoalAdvancementNode&& obj) = default;
  SwigObj_inworld_GoalAdvancementNode* swig_self() const noexcept { return (SwigObj_inworld_GoalAdvancementNode*)TypedNode_GoalAdvancement_EventHistory_Json_Text_Text_Text_Text_MatchedIntents_Text_Text::swig_self(); }
};

class TypedNode_MatchedIntents : public TypedNodeBase {
public:
  static TypedNode_MatchedIntents null() { return TypedNode_MatchedIntents{(SwigObj_inworld_TypedNode_MatchedIntents*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_MatchedIntents() {
    if (swig_owns_self_) {
      inworld_TypedNode_MatchedIntents_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_MatchedIntents(SwigObj_inworld_TypedNode_MatchedIntents* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_MatchedIntents(TypedNode_MatchedIntents const&) = delete;
  TypedNode_MatchedIntents& operator=(TypedNode_MatchedIntents const&) = delete;
  TypedNode_MatchedIntents(TypedNode_MatchedIntents&& obj) = default;
  TypedNode_MatchedIntents& operator=(TypedNode_MatchedIntents&& obj) = default;
  SwigObj_inworld_TypedNode_MatchedIntents* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_MatchedIntents*)TypedNodeBase::swig_self(); }
};

class StatusOr_SharedPtr_IntentNode {
public:
  StatusOr_SharedPtr_IntentNode();
  StatusOr_SharedPtr_IntentNode(IntentNode const& value);
  StatusOr_SharedPtr_IntentNode(Status const & status);
  bool ok() const;
  Status status() const;
  IntentNode value() const;
  StatusOr_SharedPtr_IntentNode(StatusOr_SharedPtr_IntentNode const & other);
  ~StatusOr_SharedPtr_IntentNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_IntentNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_IntentNode(SwigObj_inworld_StatusOr_SharedPtr_IntentNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_IntentNode& operator=(StatusOr_SharedPtr_IntentNode const&) = delete;
  StatusOr_SharedPtr_IntentNode(StatusOr_SharedPtr_IntentNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_IntentNode& operator=(StatusOr_SharedPtr_IntentNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_IntentNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_IntentNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_IntentNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_MatchedIntents {
public:
  StatusOr_SharedPtr_MatchedIntents();
  StatusOr_SharedPtr_MatchedIntents(MatchedIntents const& value);
  StatusOr_SharedPtr_MatchedIntents(Status const & status);
  bool ok() const;
  Status status() const;
  MatchedIntents value() const;
  StatusOr_SharedPtr_MatchedIntents(StatusOr_SharedPtr_MatchedIntents const & other);
  ~StatusOr_SharedPtr_MatchedIntents() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MatchedIntents_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_MatchedIntents(SwigObj_inworld_StatusOr_SharedPtr_MatchedIntents* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_MatchedIntents& operator=(StatusOr_SharedPtr_MatchedIntents const&) = delete;
  StatusOr_SharedPtr_MatchedIntents(StatusOr_SharedPtr_MatchedIntents&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_MatchedIntents& operator=(StatusOr_SharedPtr_MatchedIntents&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MatchedIntents_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_MatchedIntents* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_MatchedIntents* swig_self_;
  bool swig_owns_self_;
};

class optional_TextEmbedderCreationConfig {
public:
  optional_TextEmbedderCreationConfig();
  optional_TextEmbedderCreationConfig(TextEmbedderCreationConfig const & value);
  optional_TextEmbedderCreationConfig(optional_TextEmbedderCreationConfig const & other);
  ~optional_TextEmbedderCreationConfig() {
    if (swig_owns_self_)
      inworld_optional_TextEmbedderCreationConfig_delete(swig_self_);
  }
  bool has_value() const;
  TextEmbedderCreationConfig value();
  TextEmbedderCreationConfig value() const;
  TextEmbedderCreationConfig value_or(TextEmbedderCreationConfig const & default_value) const;
  void reset();
  TextEmbedderCreationConfig operator *();
  TextEmbedderCreationConfig operator *() const;
  TextEmbedderCreationConfig get_value();
  void set_value(TextEmbedderCreationConfig & t);

  explicit optional_TextEmbedderCreationConfig(SwigObj_inworld_optional_TextEmbedderCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_TextEmbedderCreationConfig& operator=(optional_TextEmbedderCreationConfig const&) = delete;
  optional_TextEmbedderCreationConfig(optional_TextEmbedderCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_TextEmbedderCreationConfig& operator=(optional_TextEmbedderCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_TextEmbedderCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_TextEmbedderCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_TextEmbedderCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class optional_LLMCreationConfig {
public:
  optional_LLMCreationConfig();
  optional_LLMCreationConfig(LLMCreationConfig const & value);
  optional_LLMCreationConfig(optional_LLMCreationConfig const & other);
  ~optional_LLMCreationConfig() {
    if (swig_owns_self_)
      inworld_optional_LLMCreationConfig_delete(swig_self_);
  }
  bool has_value() const;
  LLMCreationConfig value();
  LLMCreationConfig value() const;
  LLMCreationConfig value_or(LLMCreationConfig const & default_value) const;
  void reset();
  LLMCreationConfig operator *();
  LLMCreationConfig operator *() const;
  LLMCreationConfig get_value();
  void set_value(LLMCreationConfig & t);

  explicit optional_LLMCreationConfig(SwigObj_inworld_optional_LLMCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_LLMCreationConfig& operator=(optional_LLMCreationConfig const&) = delete;
  optional_LLMCreationConfig(optional_LLMCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_LLMCreationConfig& operator=(optional_LLMCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_LLMCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_LLMCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_LLMCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class IntentNodeExecutionConfig : public NodeExecutionConfig {
public:
  static IntentNodeExecutionConfig null() { return IntentNodeExecutionConfig{(SwigObj_inworld_IntentNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void matcher_config(IntentMatcherConfig * matcher_config);
  IntentMatcherConfig * matcher_config() const;
  bool is_valid() const;
  IntentNodeExecutionConfig();
  IntentNodeExecutionConfig(IntentNodeExecutionConfig const & other);
  ~IntentNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_IntentNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit IntentNodeExecutionConfig(SwigObj_inworld_IntentNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  IntentNodeExecutionConfig& operator=(IntentNodeExecutionConfig const&) = delete;
  IntentNodeExecutionConfig(IntentNodeExecutionConfig&& obj) = default;
  IntentNodeExecutionConfig& operator=(IntentNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_IntentNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_IntentNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class IntentNodeCreationConfig {
public:
  void intents(vector_Intent * intents);
  vector_Intent * intents() const;
  void embedder_component_id(optional_string * embedder_component_id);
  optional_string * embedder_component_id() const;
  void llm_component_id(optional_string * llm_component_id);
  optional_string * llm_component_id() const;
  IntentNodeCreationConfig();
  IntentNodeCreationConfig(IntentNodeCreationConfig const & other);
  ~IntentNodeCreationConfig() {
    if (swig_owns_self_)
      inworld_IntentNodeCreationConfig_delete(swig_self_);
  }

  explicit IntentNodeCreationConfig(SwigObj_inworld_IntentNodeCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  IntentNodeCreationConfig& operator=(IntentNodeCreationConfig const&) = delete;
  IntentNodeCreationConfig(IntentNodeCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  IntentNodeCreationConfig& operator=(IntentNodeCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_IntentNodeCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_IntentNodeCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_IntentNodeCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class IntentNode : public TypedNode_MatchedIntents {
public:
  static IntentNode null() { return IntentNode{(SwigObj_inworld_IntentNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_IntentNode inworld_inworld_graphs_IntentNode_Create__SWIG(std::string const& id, CreationContext const & arg2, IntentNodeCreationConfig const & arg3, IntentNodeExecutionConfig const& arg4);
  ~IntentNode() {
    if (swig_owns_self_) {
      inworld_IntentNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit IntentNode(SwigObj_inworld_IntentNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_MatchedIntents{(SwigObj_inworld_TypedNode_MatchedIntents*)swig_self, swig_owns_self} {}
  IntentNode(IntentNode const&) = delete;
  IntentNode& operator=(IntentNode const&) = delete;
  IntentNode(IntentNode&& obj) = default;
  IntentNode& operator=(IntentNode&& obj) = default;
  SwigObj_inworld_IntentNode* swig_self() const noexcept { return (SwigObj_inworld_IntentNode*)TypedNode_MatchedIntents::swig_self(); }
};

class TypedNode_MatchedKeywords : public TypedNodeBase {
public:
  static TypedNode_MatchedKeywords null() { return TypedNode_MatchedKeywords{(SwigObj_inworld_TypedNode_MatchedKeywords*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_MatchedKeywords() {
    if (swig_owns_self_) {
      inworld_TypedNode_MatchedKeywords_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_MatchedKeywords(SwigObj_inworld_TypedNode_MatchedKeywords* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_MatchedKeywords(TypedNode_MatchedKeywords const&) = delete;
  TypedNode_MatchedKeywords& operator=(TypedNode_MatchedKeywords const&) = delete;
  TypedNode_MatchedKeywords(TypedNode_MatchedKeywords&& obj) = default;
  TypedNode_MatchedKeywords& operator=(TypedNode_MatchedKeywords&& obj) = default;
  SwigObj_inworld_TypedNode_MatchedKeywords* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_MatchedKeywords*)TypedNodeBase::swig_self(); }
};

class StatusOr_SharedPtr_KeywordMatcherNode {
public:
  StatusOr_SharedPtr_KeywordMatcherNode();
  StatusOr_SharedPtr_KeywordMatcherNode(KeywordMatcherNode const& value);
  StatusOr_SharedPtr_KeywordMatcherNode(Status const & status);
  bool ok() const;
  Status status() const;
  KeywordMatcherNode value() const;
  StatusOr_SharedPtr_KeywordMatcherNode(StatusOr_SharedPtr_KeywordMatcherNode const & other);
  ~StatusOr_SharedPtr_KeywordMatcherNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_KeywordMatcherNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_KeywordMatcherNode(SwigObj_inworld_StatusOr_SharedPtr_KeywordMatcherNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_KeywordMatcherNode& operator=(StatusOr_SharedPtr_KeywordMatcherNode const&) = delete;
  StatusOr_SharedPtr_KeywordMatcherNode(StatusOr_SharedPtr_KeywordMatcherNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_KeywordMatcherNode& operator=(StatusOr_SharedPtr_KeywordMatcherNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_KeywordMatcherNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_KeywordMatcherNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_KeywordMatcherNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_MatchedKeywords {
public:
  StatusOr_SharedPtr_MatchedKeywords();
  StatusOr_SharedPtr_MatchedKeywords(MatchedKeywords const& value);
  StatusOr_SharedPtr_MatchedKeywords(Status const & status);
  bool ok() const;
  Status status() const;
  MatchedKeywords value() const;
  StatusOr_SharedPtr_MatchedKeywords(StatusOr_SharedPtr_MatchedKeywords const & other);
  ~StatusOr_SharedPtr_MatchedKeywords() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MatchedKeywords_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_MatchedKeywords(SwigObj_inworld_StatusOr_SharedPtr_MatchedKeywords* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_MatchedKeywords& operator=(StatusOr_SharedPtr_MatchedKeywords const&) = delete;
  StatusOr_SharedPtr_MatchedKeywords(StatusOr_SharedPtr_MatchedKeywords&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_MatchedKeywords& operator=(StatusOr_SharedPtr_MatchedKeywords&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MatchedKeywords_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_MatchedKeywords* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_MatchedKeywords* swig_self_;
  bool swig_owns_self_;
};

class KeywordMatcherNodeCreationConfig {
public:
  void keyword_groups(vector_KeywordGroup * keyword_groups);
  vector_KeywordGroup * keyword_groups() const;
  KeywordMatcherNodeCreationConfig();
  KeywordMatcherNodeCreationConfig(KeywordMatcherNodeCreationConfig const & other);
  ~KeywordMatcherNodeCreationConfig() {
    if (swig_owns_self_)
      inworld_KeywordMatcherNodeCreationConfig_delete(swig_self_);
  }

  explicit KeywordMatcherNodeCreationConfig(SwigObj_inworld_KeywordMatcherNodeCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KeywordMatcherNodeCreationConfig& operator=(KeywordMatcherNodeCreationConfig const&) = delete;
  KeywordMatcherNodeCreationConfig(KeywordMatcherNodeCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KeywordMatcherNodeCreationConfig& operator=(KeywordMatcherNodeCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KeywordMatcherNodeCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KeywordMatcherNodeCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KeywordMatcherNodeCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class KeywordMatcherNode : public TypedNode_MatchedKeywords {
public:
  static KeywordMatcherNode null() { return KeywordMatcherNode{(SwigObj_inworld_KeywordMatcherNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_KeywordMatcherNode inworld_inworld_graphs_KeywordMatcherNode_Create__SWIG_0(std::string const& id, KeywordMatcherNodeCreationConfig const & arg2);
  static StatusOr_SharedPtr_KeywordMatcherNode inworld_inworld_graphs_KeywordMatcherNode_Create__SWIG_1(std::string const& id, KeywordMatcherNodeCreationConfig const & arg2, NodeExecutionConfig const& arg3);
  KeywordMatcherNode(KeywordMatcherNode const & other);
  ~KeywordMatcherNode() {
    if (swig_owns_self_) {
      inworld_KeywordMatcherNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit KeywordMatcherNode(SwigObj_inworld_KeywordMatcherNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_MatchedKeywords{(SwigObj_inworld_TypedNode_MatchedKeywords*)swig_self, swig_owns_self} {}
  KeywordMatcherNode& operator=(KeywordMatcherNode const&) = delete;
  KeywordMatcherNode(KeywordMatcherNode&& obj) = default;
  KeywordMatcherNode& operator=(KeywordMatcherNode&& obj) = default;
  SwigObj_inworld_KeywordMatcherNode* swig_self() const noexcept { return (SwigObj_inworld_KeywordMatcherNode*)TypedNode_MatchedKeywords::swig_self(); }
};

class TypedNode_KnowledgeRecords_Text_Text : public TypedNodeBase {
public:
  static TypedNode_KnowledgeRecords_Text_Text null() { return TypedNode_KnowledgeRecords_Text_Text{(SwigObj_inworld_TypedNode_KnowledgeRecords_Text_Text*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_KnowledgeRecords_Text_Text() {
    if (swig_owns_self_) {
      inworld_TypedNode_KnowledgeRecords_Text_Text_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_KnowledgeRecords_Text_Text(SwigObj_inworld_TypedNode_KnowledgeRecords_Text_Text* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_KnowledgeRecords_Text_Text(TypedNode_KnowledgeRecords_Text_Text const&) = delete;
  TypedNode_KnowledgeRecords_Text_Text& operator=(TypedNode_KnowledgeRecords_Text_Text const&) = delete;
  TypedNode_KnowledgeRecords_Text_Text(TypedNode_KnowledgeRecords_Text_Text&& obj) = default;
  TypedNode_KnowledgeRecords_Text_Text& operator=(TypedNode_KnowledgeRecords_Text_Text&& obj) = default;
  SwigObj_inworld_TypedNode_KnowledgeRecords_Text_Text* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_KnowledgeRecords_Text_Text*)TypedNodeBase::swig_self(); }
};

class StatusOr_SharedPtr_KnowledgeNode {
public:
  StatusOr_SharedPtr_KnowledgeNode();
  StatusOr_SharedPtr_KnowledgeNode(KnowledgeNode const& value);
  StatusOr_SharedPtr_KnowledgeNode(Status const & status);
  bool ok() const;
  Status status() const;
  KnowledgeNode value() const;
  StatusOr_SharedPtr_KnowledgeNode(StatusOr_SharedPtr_KnowledgeNode const & other);
  ~StatusOr_SharedPtr_KnowledgeNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_KnowledgeNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_KnowledgeNode(SwigObj_inworld_StatusOr_SharedPtr_KnowledgeNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_KnowledgeNode& operator=(StatusOr_SharedPtr_KnowledgeNode const&) = delete;
  StatusOr_SharedPtr_KnowledgeNode(StatusOr_SharedPtr_KnowledgeNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_KnowledgeNode& operator=(StatusOr_SharedPtr_KnowledgeNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_KnowledgeNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_KnowledgeNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_KnowledgeNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_KnowledgeRecords {
public:
  StatusOr_SharedPtr_KnowledgeRecords();
  StatusOr_SharedPtr_KnowledgeRecords(KnowledgeRecords const& value);
  StatusOr_SharedPtr_KnowledgeRecords(Status const & status);
  bool ok() const;
  Status status() const;
  KnowledgeRecords value() const;
  StatusOr_SharedPtr_KnowledgeRecords(StatusOr_SharedPtr_KnowledgeRecords const & other);
  ~StatusOr_SharedPtr_KnowledgeRecords() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_KnowledgeRecords_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_KnowledgeRecords(SwigObj_inworld_StatusOr_SharedPtr_KnowledgeRecords* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_KnowledgeRecords& operator=(StatusOr_SharedPtr_KnowledgeRecords const&) = delete;
  StatusOr_SharedPtr_KnowledgeRecords(StatusOr_SharedPtr_KnowledgeRecords&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_KnowledgeRecords& operator=(StatusOr_SharedPtr_KnowledgeRecords&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_KnowledgeRecords_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_KnowledgeRecords* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_KnowledgeRecords* swig_self_;
  bool swig_owns_self_;
};

class KnowledgeNodeCreationConfig {
public:
  void knowledge_id(std::string const& knowledge_id);
  std::string knowledge_id() const;
  void knowledge_records(vector_string * knowledge_records);
  vector_string * knowledge_records() const;
  void knowledge_component_id(std::string const& knowledge_component_id);
  std::string knowledge_component_id() const;
  KnowledgeNodeCreationConfig();
  KnowledgeNodeCreationConfig(KnowledgeNodeCreationConfig const & other);
  ~KnowledgeNodeCreationConfig() {
    if (swig_owns_self_)
      inworld_KnowledgeNodeCreationConfig_delete(swig_self_);
  }

  explicit KnowledgeNodeCreationConfig(SwigObj_inworld_KnowledgeNodeCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  KnowledgeNodeCreationConfig& operator=(KnowledgeNodeCreationConfig const&) = delete;
  KnowledgeNodeCreationConfig(KnowledgeNodeCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  KnowledgeNodeCreationConfig& operator=(KnowledgeNodeCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_KnowledgeNodeCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_KnowledgeNodeCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_KnowledgeNodeCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class KnowledgeNodeExecutionConfig : public NodeExecutionConfig {
public:
  static KnowledgeNodeExecutionConfig null() { return KnowledgeNodeExecutionConfig{(SwigObj_inworld_KnowledgeNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void knowledge_ids(vector_string * knowledge_ids);
  vector_string * knowledge_ids() const;
  void retrieval_config(RetrievalConfig * retrieval_config);
  RetrievalConfig * retrieval_config() const;
  bool is_valid() const;
  KnowledgeNodeExecutionConfig();
  KnowledgeNodeExecutionConfig(KnowledgeNodeExecutionConfig const & other);
  ~KnowledgeNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_KnowledgeNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit KnowledgeNodeExecutionConfig(SwigObj_inworld_KnowledgeNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  KnowledgeNodeExecutionConfig& operator=(KnowledgeNodeExecutionConfig const&) = delete;
  KnowledgeNodeExecutionConfig(KnowledgeNodeExecutionConfig&& obj) = default;
  KnowledgeNodeExecutionConfig& operator=(KnowledgeNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_KnowledgeNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_KnowledgeNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class KnowledgeNode : public TypedNode_KnowledgeRecords_Text {
public:
  static KnowledgeNode null() { return KnowledgeNode{(SwigObj_inworld_KnowledgeNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_KnowledgeNode inworld_inworld_graphs_KnowledgeNode_Create__SWIG(std::string const& id, CreationContext const & arg2, KnowledgeNodeCreationConfig const & arg3, KnowledgeNodeExecutionConfig const& arg4);
  KnowledgeNode(KnowledgeNode const & other);
  ~KnowledgeNode() {
    if (swig_owns_self_) {
      inworld_KnowledgeNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit KnowledgeNode(SwigObj_inworld_KnowledgeNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_KnowledgeRecords_Text{(SwigObj_inworld_TypedNode_KnowledgeRecords_Text*)swig_self, swig_owns_self} {}
  KnowledgeNode& operator=(KnowledgeNode const&) = delete;
  KnowledgeNode(KnowledgeNode&& obj) = default;
  KnowledgeNode& operator=(KnowledgeNode&& obj) = default;
  SwigObj_inworld_KnowledgeNode* swig_self() const noexcept { return (SwigObj_inworld_KnowledgeNode*)TypedNode_KnowledgeRecords_Text::swig_self(); }
};

class StatusOr_SharedPtr_LLMChatNode {
public:
  StatusOr_SharedPtr_LLMChatNode();
  StatusOr_SharedPtr_LLMChatNode(LLMChatNode const& value);
  StatusOr_SharedPtr_LLMChatNode(Status const & status);
  bool ok() const;
  Status status() const;
  LLMChatNode value() const;
  StatusOr_SharedPtr_LLMChatNode(StatusOr_SharedPtr_LLMChatNode const & other);
  ~StatusOr_SharedPtr_LLMChatNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_LLMChatNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_LLMChatNode(SwigObj_inworld_StatusOr_SharedPtr_LLMChatNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_LLMChatNode& operator=(StatusOr_SharedPtr_LLMChatNode const&) = delete;
  StatusOr_SharedPtr_LLMChatNode(StatusOr_SharedPtr_LLMChatNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_LLMChatNode& operator=(StatusOr_SharedPtr_LLMChatNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_LLMChatNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_LLMChatNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_LLMChatNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_LLMChatResponse {
public:
  StatusOr_SharedPtr_LLMChatResponse();
  StatusOr_SharedPtr_LLMChatResponse(LLMChatResponse const& value);
  StatusOr_SharedPtr_LLMChatResponse(Status const & status);
  bool ok() const;
  Status status() const;
  LLMChatResponse value() const;
  StatusOr_SharedPtr_LLMChatResponse(StatusOr_SharedPtr_LLMChatResponse const & other);
  ~StatusOr_SharedPtr_LLMChatResponse() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_LLMChatResponse_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_LLMChatResponse(SwigObj_inworld_StatusOr_SharedPtr_LLMChatResponse* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_LLMChatResponse& operator=(StatusOr_SharedPtr_LLMChatResponse const&) = delete;
  StatusOr_SharedPtr_LLMChatResponse(StatusOr_SharedPtr_LLMChatResponse&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_LLMChatResponse& operator=(StatusOr_SharedPtr_LLMChatResponse&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_LLMChatResponse_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_LLMChatResponse* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_LLMChatResponse* swig_self_;
  bool swig_owns_self_;
};

class optional_vector_LLMRoutingConfig {
public:
  optional_vector_LLMRoutingConfig();
  optional_vector_LLMRoutingConfig(vector_LLMRoutingConfig const & value);
  optional_vector_LLMRoutingConfig(optional_vector_LLMRoutingConfig const & other);
  ~optional_vector_LLMRoutingConfig() {
    if (swig_owns_self_)
      inworld_optional_vector_LLMRoutingConfig_delete(swig_self_);
  }
  bool has_value() const;
  vector_LLMRoutingConfig value();
  vector_LLMRoutingConfig value() const;
  vector_LLMRoutingConfig value_or(vector_LLMRoutingConfig const & default_value) const;
  void reset();
  vector_LLMRoutingConfig operator *();
  vector_LLMRoutingConfig operator *() const;
  vector_LLMRoutingConfig get_value();
  void set_value(vector_LLMRoutingConfig & t);

  explicit optional_vector_LLMRoutingConfig(SwigObj_inworld_optional_vector_LLMRoutingConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_vector_LLMRoutingConfig& operator=(optional_vector_LLMRoutingConfig const&) = delete;
  optional_vector_LLMRoutingConfig(optional_vector_LLMRoutingConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_vector_LLMRoutingConfig& operator=(optional_vector_LLMRoutingConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_vector_LLMRoutingConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_vector_LLMRoutingConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_vector_LLMRoutingConfig* swig_self_;
  bool swig_owns_self_;
};

class TypedNode_LLMChatResponse_VariantInput : public TypedNodeBase {
public:
  static TypedNode_LLMChatResponse_VariantInput null() { return TypedNode_LLMChatResponse_VariantInput{(SwigObj_inworld_TypedNode_LLMChatResponse_VariantInput*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_LLMChatResponse_VariantInput() {
    if (swig_owns_self_) {
      inworld_TypedNode_LLMChatResponse_VariantInput_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_LLMChatResponse_VariantInput(SwigObj_inworld_TypedNode_LLMChatResponse_VariantInput* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_LLMChatResponse_VariantInput(TypedNode_LLMChatResponse_VariantInput const&) = delete;
  TypedNode_LLMChatResponse_VariantInput& operator=(TypedNode_LLMChatResponse_VariantInput const&) = delete;
  TypedNode_LLMChatResponse_VariantInput(TypedNode_LLMChatResponse_VariantInput&& obj) = default;
  TypedNode_LLMChatResponse_VariantInput& operator=(TypedNode_LLMChatResponse_VariantInput&& obj) = default;
  SwigObj_inworld_TypedNode_LLMChatResponse_VariantInput* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_LLMChatResponse_VariantInput*)TypedNodeBase::swig_self(); }
};

class StringTemplate {
public:
  void value(std::string const& value);
  std::string value() const;
  StringTemplate();
  StringTemplate(StringTemplate const & other);
  ~StringTemplate() {
    if (swig_owns_self_)
      inworld_StringTemplate_delete(swig_self_);
  }

  explicit StringTemplate(SwigObj_inworld_StringTemplate* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StringTemplate& operator=(StringTemplate const&) = delete;
  StringTemplate(StringTemplate&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StringTemplate& operator=(StringTemplate&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StringTemplate_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StringTemplate* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StringTemplate* swig_self_;
  bool swig_owns_self_;
};

class TextContent {
public:
  TextContent();
  TextContent(TextContent const & other);
  ~TextContent() {
    if (swig_owns_self_)
      inworld_TextContent_delete(swig_self_);
  }

  explicit TextContent(SwigObj_inworld_TextContent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextContent& operator=(TextContent const&) = delete;
  TextContent(TextContent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextContent& operator=(TextContent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextContent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextContent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextContent* swig_self_;
  bool swig_owns_self_;
};

class ImageContent {
public:
  void detail(std::string const& detail);
  std::string detail() const;
  ImageContent();
  ImageContent(ImageContent const & other);
  ~ImageContent() {
    if (swig_owns_self_)
      inworld_ImageContent_delete(swig_self_);
  }

  explicit ImageContent(SwigObj_inworld_ImageContent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ImageContent& operator=(ImageContent const&) = delete;
  ImageContent(ImageContent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ImageContent& operator=(ImageContent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ImageContent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ImageContent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ImageContent* swig_self_;
  bool swig_owns_self_;
};

class ChatMessageContent {
public:
  ChatMessageContent();
  ChatMessageContent(ChatMessageContent const & other);
  ~ChatMessageContent() {
    if (swig_owns_self_)
      inworld_ChatMessageContent_delete(swig_self_);
  }

  explicit ChatMessageContent(SwigObj_inworld_ChatMessageContent* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ChatMessageContent& operator=(ChatMessageContent const&) = delete;
  ChatMessageContent(ChatMessageContent&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ChatMessageContent& operator=(ChatMessageContent&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ChatMessageContent_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ChatMessageContent* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ChatMessageContent* swig_self_;
  bool swig_owns_self_;
};

class ChatMessage {
public:
  void role(std::string const& role);
  std::string role() const;
  bool HasSingleContent() const;
  bool HasMultimodalContent() const;
  void SetTextContent(std::string const& text);
  void SetTemplateContent(std::string const& template_str);
  void InitMultimodalContent();
  void AddTextToMultimodal(std::string const& text);
  void AddTemplateToMultimodal(std::string const& template_str);
  void AddImageToMultimodal(std::string const& url, std::string const& arg3);
  void AddImageToMultimodal(std::string const& url);
  void AddImageTemplateToMultimodal(std::string const& url_template, std::string const& arg3);
  void AddImageTemplateToMultimodal(std::string const& url_template);
  int GetMultimodalItemCount() const;
  ChatMessage();
  ChatMessage(ChatMessage const & other);
  ~ChatMessage() {
    if (swig_owns_self_)
      inworld_ChatMessage_delete(swig_self_);
  }

  explicit ChatMessage(SwigObj_inworld_ChatMessage* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  ChatMessage& operator=(ChatMessage const&) = delete;
  ChatMessage(ChatMessage&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  ChatMessage& operator=(ChatMessage&& obj) noexcept {
    if (swig_owns_self_)
      inworld_ChatMessage_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_ChatMessage* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_ChatMessage* swig_self_;
  bool swig_owns_self_;
};

class LLMChatNodeExecutionConfig : public NodeExecutionConfig {
public:
  static LLMChatNodeExecutionConfig null() { return LLMChatNodeExecutionConfig{(SwigObj_inworld_LLMChatNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void llm_component_id(std::string const& llm_component_id);
  std::string llm_component_id() const;
  void text_generation_config(optional_TextGenerationConfig * text_generation_config);
  optional_TextGenerationConfig * text_generation_config() const;
  void message_templates(optional_vector_ChatMessage * message_templates);
  optional_vector_ChatMessage * message_templates() const;
  void tools(optional_vector_Tool * tools);
  optional_vector_Tool * tools() const;
  void tool_choice(optional_ToolChoice * tool_choice);
  optional_ToolChoice * tool_choice() const;
  void stream(bool stream);
  bool stream() const;
  void response_format(ResponseFormat response_format);
  ResponseFormat response_format() const;
  bool is_valid() const;
  LLMChatNodeExecutionConfig();
  LLMChatNodeExecutionConfig(LLMChatNodeExecutionConfig const & other);
  ~LLMChatNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_LLMChatNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit LLMChatNodeExecutionConfig(SwigObj_inworld_LLMChatNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  LLMChatNodeExecutionConfig& operator=(LLMChatNodeExecutionConfig const&) = delete;
  LLMChatNodeExecutionConfig(LLMChatNodeExecutionConfig&& obj) = default;
  LLMChatNodeExecutionConfig& operator=(LLMChatNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_LLMChatNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_LLMChatNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class LLMChatNode : public TypedNode_LLMChatResponse_VariantInput {
public:
  static LLMChatNode null() { return LLMChatNode{(SwigObj_inworld_LLMChatNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_LLMChatNode inworld_inworld_graphs_LLMChatNode_Create__SWIG(std::string const& id, LLMChatNodeExecutionConfig const& arg2);
  ~LLMChatNode() {
    if (swig_owns_self_) {
      inworld_LLMChatNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit LLMChatNode(SwigObj_inworld_LLMChatNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_LLMChatResponse_VariantInput{(SwigObj_inworld_TypedNode_LLMChatResponse_VariantInput*)swig_self, swig_owns_self} {}
  LLMChatNode(LLMChatNode const&) = delete;
  LLMChatNode& operator=(LLMChatNode const&) = delete;
  LLMChatNode(LLMChatNode&& obj) = default;
  LLMChatNode& operator=(LLMChatNode&& obj) = default;
  SwigObj_inworld_LLMChatNode* swig_self() const noexcept { return (SwigObj_inworld_LLMChatNode*)TypedNode_LLMChatResponse_VariantInput::swig_self(); }
};

class StatusOr_SharedPtr_LLMCompletionNode {
public:
  StatusOr_SharedPtr_LLMCompletionNode();
  StatusOr_SharedPtr_LLMCompletionNode(LLMCompletionNode const& value);
  StatusOr_SharedPtr_LLMCompletionNode(Status const & status);
  bool ok() const;
  Status status() const;
  LLMCompletionNode value() const;
  StatusOr_SharedPtr_LLMCompletionNode(StatusOr_SharedPtr_LLMCompletionNode const & other);
  ~StatusOr_SharedPtr_LLMCompletionNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_LLMCompletionNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_LLMCompletionNode(SwigObj_inworld_StatusOr_SharedPtr_LLMCompletionNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_LLMCompletionNode& operator=(StatusOr_SharedPtr_LLMCompletionNode const&) = delete;
  StatusOr_SharedPtr_LLMCompletionNode(StatusOr_SharedPtr_LLMCompletionNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_LLMCompletionNode& operator=(StatusOr_SharedPtr_LLMCompletionNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_LLMCompletionNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_LLMCompletionNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_LLMCompletionNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_LLMCompletionResponse {
public:
  StatusOr_SharedPtr_LLMCompletionResponse();
  StatusOr_SharedPtr_LLMCompletionResponse(LLMCompletionResponse const& value);
  StatusOr_SharedPtr_LLMCompletionResponse(Status const & status);
  bool ok() const;
  Status status() const;
  LLMCompletionResponse value() const;
  StatusOr_SharedPtr_LLMCompletionResponse(StatusOr_SharedPtr_LLMCompletionResponse const & other);
  ~StatusOr_SharedPtr_LLMCompletionResponse() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_LLMCompletionResponse_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_LLMCompletionResponse(SwigObj_inworld_StatusOr_SharedPtr_LLMCompletionResponse* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_LLMCompletionResponse& operator=(StatusOr_SharedPtr_LLMCompletionResponse const&) = delete;
  StatusOr_SharedPtr_LLMCompletionResponse(StatusOr_SharedPtr_LLMCompletionResponse&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_LLMCompletionResponse& operator=(StatusOr_SharedPtr_LLMCompletionResponse&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_LLMCompletionResponse_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_LLMCompletionResponse* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_LLMCompletionResponse* swig_self_;
  bool swig_owns_self_;
};

class TypedNode_LLMCompletionResponse_VariantInput : public TypedNodeBase {
public:
  static TypedNode_LLMCompletionResponse_VariantInput null() { return TypedNode_LLMCompletionResponse_VariantInput{(SwigObj_inworld_TypedNode_LLMCompletionResponse_VariantInput*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_LLMCompletionResponse_VariantInput() {
    if (swig_owns_self_) {
      inworld_TypedNode_LLMCompletionResponse_VariantInput_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_LLMCompletionResponse_VariantInput(SwigObj_inworld_TypedNode_LLMCompletionResponse_VariantInput* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_LLMCompletionResponse_VariantInput(TypedNode_LLMCompletionResponse_VariantInput const&) = delete;
  TypedNode_LLMCompletionResponse_VariantInput& operator=(TypedNode_LLMCompletionResponse_VariantInput const&) = delete;
  TypedNode_LLMCompletionResponse_VariantInput(TypedNode_LLMCompletionResponse_VariantInput&& obj) = default;
  TypedNode_LLMCompletionResponse_VariantInput& operator=(TypedNode_LLMCompletionResponse_VariantInput&& obj) = default;
  SwigObj_inworld_TypedNode_LLMCompletionResponse_VariantInput* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_LLMCompletionResponse_VariantInput*)TypedNodeBase::swig_self(); }
};

class LLMCompletionNodeExecutionConfig : public NodeExecutionConfig {
public:
  static LLMCompletionNodeExecutionConfig null() { return LLMCompletionNodeExecutionConfig{(SwigObj_inworld_LLMCompletionNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void llm_component_id(std::string const& llm_component_id);
  std::string llm_component_id() const;
  void text_generation_config(optional_TextGenerationConfig * text_generation_config);
  optional_TextGenerationConfig * text_generation_config() const;
  void stream(bool stream);
  bool stream() const;
  void prompt_template(optional_string * prompt_template);
  optional_string * prompt_template() const;
  bool is_valid() const;
  LLMCompletionNodeExecutionConfig();
  LLMCompletionNodeExecutionConfig(LLMCompletionNodeExecutionConfig const & other);
  ~LLMCompletionNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_LLMCompletionNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit LLMCompletionNodeExecutionConfig(SwigObj_inworld_LLMCompletionNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  LLMCompletionNodeExecutionConfig& operator=(LLMCompletionNodeExecutionConfig const&) = delete;
  LLMCompletionNodeExecutionConfig(LLMCompletionNodeExecutionConfig&& obj) = default;
  LLMCompletionNodeExecutionConfig& operator=(LLMCompletionNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_LLMCompletionNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_LLMCompletionNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class LLMCompletionNode : public TypedNode_LLMCompletionResponse_VariantInput {
public:
  static LLMCompletionNode null() { return LLMCompletionNode{(SwigObj_inworld_LLMCompletionNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_LLMCompletionNode inworld_inworld_graphs_LLMCompletionNode_Create__SWIG(std::string const& id, LLMCompletionNodeExecutionConfig const& arg2);
  ~LLMCompletionNode() {
    if (swig_owns_self_) {
      inworld_LLMCompletionNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit LLMCompletionNode(SwigObj_inworld_LLMCompletionNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_LLMCompletionResponse_VariantInput{(SwigObj_inworld_TypedNode_LLMCompletionResponse_VariantInput*)swig_self, swig_owns_self} {}
  LLMCompletionNode(LLMCompletionNode const&) = delete;
  LLMCompletionNode& operator=(LLMCompletionNode const&) = delete;
  LLMCompletionNode(LLMCompletionNode&& obj) = default;
  LLMCompletionNode& operator=(LLMCompletionNode&& obj) = default;
  SwigObj_inworld_LLMCompletionNode* swig_self() const noexcept { return (SwigObj_inworld_LLMCompletionNode*)TypedNode_LLMCompletionResponse_VariantInput::swig_self(); }
};

class TypedNode_ToolCallResponse_ToolCallRequest : public TypedNodeBase {
public:
  static TypedNode_ToolCallResponse_ToolCallRequest null() { return TypedNode_ToolCallResponse_ToolCallRequest{(SwigObj_inworld_TypedNode_ToolCallResponse_ToolCallRequest*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_ToolCallResponse_ToolCallRequest() {
    if (swig_owns_self_) {
      inworld_TypedNode_ToolCallResponse_ToolCallRequest_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_ToolCallResponse_ToolCallRequest(SwigObj_inworld_TypedNode_ToolCallResponse_ToolCallRequest* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_ToolCallResponse_ToolCallRequest(TypedNode_ToolCallResponse_ToolCallRequest const&) = delete;
  TypedNode_ToolCallResponse_ToolCallRequest& operator=(TypedNode_ToolCallResponse_ToolCallRequest const&) = delete;
  TypedNode_ToolCallResponse_ToolCallRequest(TypedNode_ToolCallResponse_ToolCallRequest&& obj) = default;
  TypedNode_ToolCallResponse_ToolCallRequest& operator=(TypedNode_ToolCallResponse_ToolCallRequest&& obj) = default;
  SwigObj_inworld_TypedNode_ToolCallResponse_ToolCallRequest* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_ToolCallResponse_ToolCallRequest*)TypedNodeBase::swig_self(); }
};

class TypedNode_ListToolsResponse_Text : public TypedNodeBase {
public:
  static TypedNode_ListToolsResponse_Text null() { return TypedNode_ListToolsResponse_Text{(SwigObj_inworld_TypedNode_ListToolsResponse_Text*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_ListToolsResponse_Text() {
    if (swig_owns_self_) {
      inworld_TypedNode_ListToolsResponse_Text_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_ListToolsResponse_Text(SwigObj_inworld_TypedNode_ListToolsResponse_Text* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_ListToolsResponse_Text(TypedNode_ListToolsResponse_Text const&) = delete;
  TypedNode_ListToolsResponse_Text& operator=(TypedNode_ListToolsResponse_Text const&) = delete;
  TypedNode_ListToolsResponse_Text(TypedNode_ListToolsResponse_Text&& obj) = default;
  TypedNode_ListToolsResponse_Text& operator=(TypedNode_ListToolsResponse_Text&& obj) = default;
  SwigObj_inworld_TypedNode_ListToolsResponse_Text* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_ListToolsResponse_Text*)TypedNodeBase::swig_self(); }
};

class StatusOr_SharedPtr_MCPListToolsNode {
public:
  StatusOr_SharedPtr_MCPListToolsNode();
  StatusOr_SharedPtr_MCPListToolsNode(MCPListToolsNode const& value);
  StatusOr_SharedPtr_MCPListToolsNode(Status const & status);
  bool ok() const;
  Status status() const;
  MCPListToolsNode value() const;
  StatusOr_SharedPtr_MCPListToolsNode(StatusOr_SharedPtr_MCPListToolsNode const & other);
  ~StatusOr_SharedPtr_MCPListToolsNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MCPListToolsNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_MCPListToolsNode(SwigObj_inworld_StatusOr_SharedPtr_MCPListToolsNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_MCPListToolsNode& operator=(StatusOr_SharedPtr_MCPListToolsNode const&) = delete;
  StatusOr_SharedPtr_MCPListToolsNode(StatusOr_SharedPtr_MCPListToolsNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_MCPListToolsNode& operator=(StatusOr_SharedPtr_MCPListToolsNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MCPListToolsNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_MCPListToolsNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_MCPListToolsNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_MCPCallToolNode {
public:
  StatusOr_SharedPtr_MCPCallToolNode();
  StatusOr_SharedPtr_MCPCallToolNode(MCPCallToolNode const& value);
  StatusOr_SharedPtr_MCPCallToolNode(Status const & status);
  bool ok() const;
  Status status() const;
  MCPCallToolNode value() const;
  StatusOr_SharedPtr_MCPCallToolNode(StatusOr_SharedPtr_MCPCallToolNode const & other);
  ~StatusOr_SharedPtr_MCPCallToolNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MCPCallToolNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_MCPCallToolNode(SwigObj_inworld_StatusOr_SharedPtr_MCPCallToolNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_MCPCallToolNode& operator=(StatusOr_SharedPtr_MCPCallToolNode const&) = delete;
  StatusOr_SharedPtr_MCPCallToolNode(StatusOr_SharedPtr_MCPCallToolNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_MCPCallToolNode& operator=(StatusOr_SharedPtr_MCPCallToolNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MCPCallToolNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_MCPCallToolNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_MCPCallToolNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_ToolCallResponse {
public:
  StatusOr_SharedPtr_ToolCallResponse();
  StatusOr_SharedPtr_ToolCallResponse(ToolCallResponse const& value);
  StatusOr_SharedPtr_ToolCallResponse(Status const & status);
  bool ok() const;
  Status status() const;
  ToolCallResponse value() const;
  StatusOr_SharedPtr_ToolCallResponse(StatusOr_SharedPtr_ToolCallResponse const & other);
  ~StatusOr_SharedPtr_ToolCallResponse() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_ToolCallResponse_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_ToolCallResponse(SwigObj_inworld_StatusOr_SharedPtr_ToolCallResponse* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_ToolCallResponse& operator=(StatusOr_SharedPtr_ToolCallResponse const&) = delete;
  StatusOr_SharedPtr_ToolCallResponse(StatusOr_SharedPtr_ToolCallResponse&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_ToolCallResponse& operator=(StatusOr_SharedPtr_ToolCallResponse&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_ToolCallResponse_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_ToolCallResponse* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_ToolCallResponse* swig_self_;
  bool swig_owns_self_;
};

class MCPListToolsNodeExecutionConfig : public NodeExecutionConfig {
public:
  static MCPListToolsNodeExecutionConfig null() { return MCPListToolsNodeExecutionConfig{(SwigObj_inworld_MCPListToolsNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void mcp_component_id(std::string const& mcp_component_id);
  std::string mcp_component_id() const;
  bool is_valid() const;
  MCPListToolsNodeExecutionConfig();
  MCPListToolsNodeExecutionConfig(MCPListToolsNodeExecutionConfig const & other);
  ~MCPListToolsNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_MCPListToolsNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MCPListToolsNodeExecutionConfig(SwigObj_inworld_MCPListToolsNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  MCPListToolsNodeExecutionConfig& operator=(MCPListToolsNodeExecutionConfig const&) = delete;
  MCPListToolsNodeExecutionConfig(MCPListToolsNodeExecutionConfig&& obj) = default;
  MCPListToolsNodeExecutionConfig& operator=(MCPListToolsNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_MCPListToolsNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_MCPListToolsNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class MCPListToolsNode : public Node {
public:
  static MCPListToolsNode null() { return MCPListToolsNode{(SwigObj_inworld_MCPListToolsNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_MCPListToolsNode inworld_inworld_graphs_MCPListToolsNode_Create__SWIG(std::string const& id, MCPListToolsNodeExecutionConfig const& arg2);
  ~MCPListToolsNode() {
    if (swig_owns_self_) {
      inworld_MCPListToolsNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MCPListToolsNode(SwigObj_inworld_MCPListToolsNode* swig_self, bool swig_owns_self = true) noexcept : Node{(SwigObj_inworld_Node*)swig_self, swig_owns_self} {}
  MCPListToolsNode(MCPListToolsNode const&) = delete;
  MCPListToolsNode& operator=(MCPListToolsNode const&) = delete;
  MCPListToolsNode(MCPListToolsNode&& obj) = default;
  MCPListToolsNode& operator=(MCPListToolsNode&& obj) = default;
  SwigObj_inworld_MCPListToolsNode* swig_self() const noexcept { return (SwigObj_inworld_MCPListToolsNode*)Node::swig_self(); }
};

class MCPCallToolNodeExecutionConfig : public NodeExecutionConfig {
public:
  static MCPCallToolNodeExecutionConfig null() { return MCPCallToolNodeExecutionConfig{(SwigObj_inworld_MCPCallToolNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void mcp_component_id(std::string const& mcp_component_id);
  std::string mcp_component_id() const;
  bool is_valid() const;
  MCPCallToolNodeExecutionConfig();
  MCPCallToolNodeExecutionConfig(MCPCallToolNodeExecutionConfig const & other);
  ~MCPCallToolNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_MCPCallToolNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MCPCallToolNodeExecutionConfig(SwigObj_inworld_MCPCallToolNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  MCPCallToolNodeExecutionConfig& operator=(MCPCallToolNodeExecutionConfig const&) = delete;
  MCPCallToolNodeExecutionConfig(MCPCallToolNodeExecutionConfig&& obj) = default;
  MCPCallToolNodeExecutionConfig& operator=(MCPCallToolNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_MCPCallToolNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_MCPCallToolNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class MCPCallToolNode : public TypedNode_ToolCallResponse_ToolCallRequest {
public:
  static MCPCallToolNode null() { return MCPCallToolNode{(SwigObj_inworld_MCPCallToolNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_MCPCallToolNode inworld_inworld_graphs_MCPCallToolNode_Create__SWIG(std::string const& id, MCPCallToolNodeExecutionConfig const& arg2);
  ~MCPCallToolNode() {
    if (swig_owns_self_) {
      inworld_MCPCallToolNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MCPCallToolNode(SwigObj_inworld_MCPCallToolNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_ToolCallResponse_ToolCallRequest{(SwigObj_inworld_TypedNode_ToolCallResponse_ToolCallRequest*)swig_self, swig_owns_self} {}
  MCPCallToolNode(MCPCallToolNode const&) = delete;
  MCPCallToolNode& operator=(MCPCallToolNode const&) = delete;
  MCPCallToolNode(MCPCallToolNode&& obj) = default;
  MCPCallToolNode& operator=(MCPCallToolNode&& obj) = default;
  SwigObj_inworld_MCPCallToolNode* swig_self() const noexcept { return (SwigObj_inworld_MCPCallToolNode*)TypedNode_ToolCallResponse_ToolCallRequest::swig_self(); }
};

class TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text : public TypedNodeBase {
public:
  static TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text null() { return TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text{(SwigObj_inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text() {
    if (swig_owns_self_) {
      inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text(SwigObj_inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text(TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text const&) = delete;
  TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text& operator=(TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text const&) = delete;
  TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text(TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text&& obj) = default;
  TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text& operator=(TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text&& obj) = default;
  SwigObj_inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text*)TypedNodeBase::swig_self(); }
};

class TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text : public TypedNodeBase {
public:
  static TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text null() { return TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text{(SwigObj_inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text() {
    if (swig_owns_self_) {
      inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text(SwigObj_inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text(TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text const&) = delete;
  TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text& operator=(TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text const&) = delete;
  TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text(TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text&& obj) = default;
  TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text& operator=(TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text&& obj) = default;
  SwigObj_inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text*)TypedNodeBase::swig_self(); }
};

class StatusOr_SharedPtr_MemoryUpdateNode {
public:
  StatusOr_SharedPtr_MemoryUpdateNode();
  StatusOr_SharedPtr_MemoryUpdateNode(MemoryUpdateNode const& value);
  StatusOr_SharedPtr_MemoryUpdateNode(Status const & status);
  bool ok() const;
  Status status() const;
  MemoryUpdateNode value() const;
  StatusOr_SharedPtr_MemoryUpdateNode(StatusOr_SharedPtr_MemoryUpdateNode const & other);
  ~StatusOr_SharedPtr_MemoryUpdateNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MemoryUpdateNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_MemoryUpdateNode(SwigObj_inworld_StatusOr_SharedPtr_MemoryUpdateNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_MemoryUpdateNode& operator=(StatusOr_SharedPtr_MemoryUpdateNode const&) = delete;
  StatusOr_SharedPtr_MemoryUpdateNode(StatusOr_SharedPtr_MemoryUpdateNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_MemoryUpdateNode& operator=(StatusOr_SharedPtr_MemoryUpdateNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MemoryUpdateNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_MemoryUpdateNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_MemoryUpdateNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_MemoryRetrieveNode {
public:
  StatusOr_SharedPtr_MemoryRetrieveNode();
  StatusOr_SharedPtr_MemoryRetrieveNode(MemoryRetrieveNode const& value);
  StatusOr_SharedPtr_MemoryRetrieveNode(Status const & status);
  bool ok() const;
  Status status() const;
  MemoryRetrieveNode value() const;
  StatusOr_SharedPtr_MemoryRetrieveNode(StatusOr_SharedPtr_MemoryRetrieveNode const & other);
  ~StatusOr_SharedPtr_MemoryRetrieveNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MemoryRetrieveNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_MemoryRetrieveNode(SwigObj_inworld_StatusOr_SharedPtr_MemoryRetrieveNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_MemoryRetrieveNode& operator=(StatusOr_SharedPtr_MemoryRetrieveNode const&) = delete;
  StatusOr_SharedPtr_MemoryRetrieveNode(StatusOr_SharedPtr_MemoryRetrieveNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_MemoryRetrieveNode& operator=(StatusOr_SharedPtr_MemoryRetrieveNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_MemoryRetrieveNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_MemoryRetrieveNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_MemoryRetrieveNode* swig_self_;
  bool swig_owns_self_;
};

class MemoryUpdateNodeCreationConfig {
public:
  void llm_component_id(std::string const& llm_component_id);
  std::string llm_component_id() const;
  void embedder_component_id(std::string const& embedder_component_id);
  std::string embedder_component_id() const;
  void memory_update_config(MemoryUpdateConfig * memory_update_config);
  MemoryUpdateConfig * memory_update_config() const;
  MemoryUpdateNodeCreationConfig();
  MemoryUpdateNodeCreationConfig(MemoryUpdateNodeCreationConfig const & other);
  ~MemoryUpdateNodeCreationConfig() {
    if (swig_owns_self_)
      inworld_MemoryUpdateNodeCreationConfig_delete(swig_self_);
  }

  explicit MemoryUpdateNodeCreationConfig(SwigObj_inworld_MemoryUpdateNodeCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MemoryUpdateNodeCreationConfig& operator=(MemoryUpdateNodeCreationConfig const&) = delete;
  MemoryUpdateNodeCreationConfig(MemoryUpdateNodeCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MemoryUpdateNodeCreationConfig& operator=(MemoryUpdateNodeCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MemoryUpdateNodeCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MemoryUpdateNodeCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MemoryUpdateNodeCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class MemoryRetrieveNodeCreationConfig {
public:
  void llm_component_id(std::string const& llm_component_id);
  std::string llm_component_id() const;
  void embedder_component_id(std::string const& embedder_component_id);
  std::string embedder_component_id() const;
  MemoryRetrieveNodeCreationConfig();
  MemoryRetrieveNodeCreationConfig(MemoryRetrieveNodeCreationConfig const & other);
  ~MemoryRetrieveNodeCreationConfig() {
    if (swig_owns_self_)
      inworld_MemoryRetrieveNodeCreationConfig_delete(swig_self_);
  }

  explicit MemoryRetrieveNodeCreationConfig(SwigObj_inworld_MemoryRetrieveNodeCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  MemoryRetrieveNodeCreationConfig& operator=(MemoryRetrieveNodeCreationConfig const&) = delete;
  MemoryRetrieveNodeCreationConfig(MemoryRetrieveNodeCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  MemoryRetrieveNodeCreationConfig& operator=(MemoryRetrieveNodeCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_MemoryRetrieveNodeCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_MemoryRetrieveNodeCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_MemoryRetrieveNodeCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class MemoryRetrieveNodeExecutionConfig : public NodeExecutionConfig {
public:
  static MemoryRetrieveNodeExecutionConfig null() { return MemoryRetrieveNodeExecutionConfig{(SwigObj_inworld_MemoryRetrieveNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void retrieval_config(RetrievalConfig * retrieval_config);
  RetrievalConfig * retrieval_config() const;
  void return_rolling_summary(bool return_rolling_summary);
  bool return_rolling_summary() const;
  bool is_valid() const;
  MemoryRetrieveNodeExecutionConfig();
  MemoryRetrieveNodeExecutionConfig(MemoryRetrieveNodeExecutionConfig const & other);
  ~MemoryRetrieveNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_MemoryRetrieveNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MemoryRetrieveNodeExecutionConfig(SwigObj_inworld_MemoryRetrieveNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  MemoryRetrieveNodeExecutionConfig& operator=(MemoryRetrieveNodeExecutionConfig const&) = delete;
  MemoryRetrieveNodeExecutionConfig(MemoryRetrieveNodeExecutionConfig&& obj) = default;
  MemoryRetrieveNodeExecutionConfig& operator=(MemoryRetrieveNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_MemoryRetrieveNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_MemoryRetrieveNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class MemoryUpdateNode : public TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text {
public:
  static MemoryUpdateNode null() { return MemoryUpdateNode{(SwigObj_inworld_MemoryUpdateNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_MemoryUpdateNode inworld_inworld_graphs_MemoryUpdateNode_Create__SWIG_0(std::string const& id, CreationContext const & arg2, MemoryUpdateNodeCreationConfig const & arg3);
  static StatusOr_SharedPtr_MemoryUpdateNode inworld_inworld_graphs_MemoryUpdateNode_Create__SWIG_1(std::string const& id, CreationContext const & arg2, MemoryUpdateNodeCreationConfig const & arg3, NodeExecutionConfig const& arg4);
  MemoryUpdateNode(MemoryUpdateNode const & other);
  ~MemoryUpdateNode() {
    if (swig_owns_self_) {
      inworld_MemoryUpdateNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MemoryUpdateNode(SwigObj_inworld_MemoryUpdateNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text{(SwigObj_inworld_TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text*)swig_self, swig_owns_self} {}
  MemoryUpdateNode& operator=(MemoryUpdateNode const&) = delete;
  MemoryUpdateNode(MemoryUpdateNode&& obj) = default;
  MemoryUpdateNode& operator=(MemoryUpdateNode&& obj) = default;
  SwigObj_inworld_MemoryUpdateNode* swig_self() const noexcept { return (SwigObj_inworld_MemoryUpdateNode*)TypedNode_MemoryState_EventHistory_MemoryState_Text_Text_Text_Text::swig_self(); }
};

class MemoryRetrieveNode : public TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text {
public:
  static MemoryRetrieveNode null() { return MemoryRetrieveNode{(SwigObj_inworld_MemoryRetrieveNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_MemoryRetrieveNode inworld_inworld_graphs_MemoryRetrieveNode_Create__SWIG(std::string const& id, CreationContext const & arg2, MemoryRetrieveNodeCreationConfig const & arg3, MemoryRetrieveNodeExecutionConfig const& arg4);
  MemoryRetrieveNode(MemoryRetrieveNode const & other);
  ~MemoryRetrieveNode() {
    if (swig_owns_self_) {
      inworld_MemoryRetrieveNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MemoryRetrieveNode(SwigObj_inworld_MemoryRetrieveNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text{(SwigObj_inworld_TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text*)swig_self, swig_owns_self} {}
  MemoryRetrieveNode& operator=(MemoryRetrieveNode const&) = delete;
  MemoryRetrieveNode(MemoryRetrieveNode&& obj) = default;
  MemoryRetrieveNode& operator=(MemoryRetrieveNode&& obj) = default;
  SwigObj_inworld_MemoryRetrieveNode* swig_self() const noexcept { return (SwigObj_inworld_MemoryRetrieveNode*)TypedNode_KnowledgeRecords_EventHistory_MemoryState_Text_Text::swig_self(); }
};

class StatusOr_SharedPtr_RandomCannedTextNode {
public:
  StatusOr_SharedPtr_RandomCannedTextNode();
  StatusOr_SharedPtr_RandomCannedTextNode(RandomCannedTextNode const& value);
  StatusOr_SharedPtr_RandomCannedTextNode(Status const & status);
  bool ok() const;
  Status status() const;
  RandomCannedTextNode value() const;
  StatusOr_SharedPtr_RandomCannedTextNode(StatusOr_SharedPtr_RandomCannedTextNode const & other);
  ~StatusOr_SharedPtr_RandomCannedTextNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_RandomCannedTextNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_RandomCannedTextNode(SwigObj_inworld_StatusOr_SharedPtr_RandomCannedTextNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_RandomCannedTextNode& operator=(StatusOr_SharedPtr_RandomCannedTextNode const&) = delete;
  StatusOr_SharedPtr_RandomCannedTextNode(StatusOr_SharedPtr_RandomCannedTextNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_RandomCannedTextNode& operator=(StatusOr_SharedPtr_RandomCannedTextNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_RandomCannedTextNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_RandomCannedTextNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_RandomCannedTextNode* swig_self_;
  bool swig_owns_self_;
};

class RandomCannedTextNodeExecutionConfig : public NodeExecutionConfig {
public:
  static RandomCannedTextNodeExecutionConfig null() { return RandomCannedTextNodeExecutionConfig{(SwigObj_inworld_RandomCannedTextNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void canned_phrases(vector_string * canned_phrases);
  vector_string * canned_phrases() const;
  bool is_valid() const;
  RandomCannedTextNodeExecutionConfig();
  RandomCannedTextNodeExecutionConfig(RandomCannedTextNodeExecutionConfig const & other);
  ~RandomCannedTextNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_RandomCannedTextNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit RandomCannedTextNodeExecutionConfig(SwigObj_inworld_RandomCannedTextNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  RandomCannedTextNodeExecutionConfig& operator=(RandomCannedTextNodeExecutionConfig const&) = delete;
  RandomCannedTextNodeExecutionConfig(RandomCannedTextNodeExecutionConfig&& obj) = default;
  RandomCannedTextNodeExecutionConfig& operator=(RandomCannedTextNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_RandomCannedTextNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_RandomCannedTextNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class RandomCannedTextNode : public Node {
public:
  static RandomCannedTextNode null() { return RandomCannedTextNode{(SwigObj_inworld_RandomCannedTextNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_RandomCannedTextNode inworld_inworld_graphs_RandomCannedTextNode_Create__SWIG(std::string const& id, RandomCannedTextNodeExecutionConfig const& arg2);
  RandomCannedTextNode(RandomCannedTextNode const & other);
  ~RandomCannedTextNode() {
    if (swig_owns_self_) {
      inworld_RandomCannedTextNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit RandomCannedTextNode(SwigObj_inworld_RandomCannedTextNode* swig_self, bool swig_owns_self = true) noexcept : Node{(SwigObj_inworld_Node*)swig_self, swig_owns_self} {}
  RandomCannedTextNode& operator=(RandomCannedTextNode const&) = delete;
  RandomCannedTextNode(RandomCannedTextNode&& obj) = default;
  RandomCannedTextNode& operator=(RandomCannedTextNode&& obj) = default;
  SwigObj_inworld_RandomCannedTextNode* swig_self() const noexcept { return (SwigObj_inworld_RandomCannedTextNode*)Node::swig_self(); }
};

class TypedNode_SafetyResult : public TypedNodeBase {
public:
  static TypedNode_SafetyResult null() { return TypedNode_SafetyResult{(SwigObj_inworld_TypedNode_SafetyResult*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_SafetyResult() {
    if (swig_owns_self_) {
      inworld_TypedNode_SafetyResult_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_SafetyResult(SwigObj_inworld_TypedNode_SafetyResult* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_SafetyResult(TypedNode_SafetyResult const&) = delete;
  TypedNode_SafetyResult& operator=(TypedNode_SafetyResult const&) = delete;
  TypedNode_SafetyResult(TypedNode_SafetyResult&& obj) = default;
  TypedNode_SafetyResult& operator=(TypedNode_SafetyResult&& obj) = default;
  SwigObj_inworld_TypedNode_SafetyResult* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_SafetyResult*)TypedNodeBase::swig_self(); }
};

class StatusOr_SharedPtr_SafetyCheckerNode {
public:
  StatusOr_SharedPtr_SafetyCheckerNode();
  StatusOr_SharedPtr_SafetyCheckerNode(SafetyCheckerNode const& value);
  StatusOr_SharedPtr_SafetyCheckerNode(Status const & status);
  bool ok() const;
  Status status() const;
  SafetyCheckerNode value() const;
  StatusOr_SharedPtr_SafetyCheckerNode(StatusOr_SharedPtr_SafetyCheckerNode const & other);
  ~StatusOr_SharedPtr_SafetyCheckerNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_SafetyCheckerNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_SafetyCheckerNode(SwigObj_inworld_StatusOr_SharedPtr_SafetyCheckerNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_SafetyCheckerNode& operator=(StatusOr_SharedPtr_SafetyCheckerNode const&) = delete;
  StatusOr_SharedPtr_SafetyCheckerNode(StatusOr_SharedPtr_SafetyCheckerNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_SafetyCheckerNode& operator=(StatusOr_SharedPtr_SafetyCheckerNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_SafetyCheckerNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_SafetyCheckerNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_SafetyCheckerNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_SafetyResult {
public:
  StatusOr_SharedPtr_SafetyResult();
  StatusOr_SharedPtr_SafetyResult(SafetyResult const& value);
  StatusOr_SharedPtr_SafetyResult(Status const & status);
  bool ok() const;
  Status status() const;
  SafetyResult value() const;
  StatusOr_SharedPtr_SafetyResult(StatusOr_SharedPtr_SafetyResult const & other);
  ~StatusOr_SharedPtr_SafetyResult() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_SafetyResult_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_SafetyResult(SwigObj_inworld_StatusOr_SharedPtr_SafetyResult* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_SafetyResult& operator=(StatusOr_SharedPtr_SafetyResult const&) = delete;
  StatusOr_SharedPtr_SafetyResult(StatusOr_SharedPtr_SafetyResult&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_SafetyResult& operator=(StatusOr_SharedPtr_SafetyResult&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_SafetyResult_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_SafetyResult* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_SafetyResult* swig_self_;
  bool swig_owns_self_;
};

class optional_SafetyConfig {
public:
  optional_SafetyConfig();
  optional_SafetyConfig(SafetyConfig const & value);
  optional_SafetyConfig(optional_SafetyConfig const & other);
  ~optional_SafetyConfig() {
    if (swig_owns_self_)
      inworld_optional_SafetyConfig_delete(swig_self_);
  }
  bool has_value() const;
  SafetyConfig value();
  SafetyConfig value() const;
  SafetyConfig value_or(SafetyConfig const & default_value) const;
  void reset();
  SafetyConfig operator *();
  SafetyConfig operator *() const;
  SafetyConfig get_value();
  void set_value(SafetyConfig & t);

  explicit optional_SafetyConfig(SwigObj_inworld_optional_SafetyConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  optional_SafetyConfig& operator=(optional_SafetyConfig const&) = delete;
  optional_SafetyConfig(optional_SafetyConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  optional_SafetyConfig& operator=(optional_SafetyConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_optional_SafetyConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_optional_SafetyConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_optional_SafetyConfig* swig_self_;
  bool swig_owns_self_;
};

class SafetyCheckerNodeCreationConfig {
public:
  void embedder_component_id(std::string const& embedder_component_id);
  std::string embedder_component_id() const;
  void safety_config(SafetyCheckerCreationConfig * safety_config);
  SafetyCheckerCreationConfig * safety_config() const;
  SafetyCheckerNodeCreationConfig();
  SafetyCheckerNodeCreationConfig(SafetyCheckerNodeCreationConfig const & other);
  ~SafetyCheckerNodeCreationConfig() {
    if (swig_owns_self_)
      inworld_SafetyCheckerNodeCreationConfig_delete(swig_self_);
  }

  explicit SafetyCheckerNodeCreationConfig(SwigObj_inworld_SafetyCheckerNodeCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  SafetyCheckerNodeCreationConfig& operator=(SafetyCheckerNodeCreationConfig const&) = delete;
  SafetyCheckerNodeCreationConfig(SafetyCheckerNodeCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  SafetyCheckerNodeCreationConfig& operator=(SafetyCheckerNodeCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_SafetyCheckerNodeCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_SafetyCheckerNodeCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_SafetyCheckerNodeCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class SafetyCheckerNodeExecutionConfig : public NodeExecutionConfig {
public:
  static SafetyCheckerNodeExecutionConfig null() { return SafetyCheckerNodeExecutionConfig{(SwigObj_inworld_SafetyCheckerNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void safety_config(optional_SafetyConfig * safety_config);
  optional_SafetyConfig * safety_config() const;
  bool is_valid() const;
  SafetyCheckerNodeExecutionConfig();
  SafetyCheckerNodeExecutionConfig(SafetyCheckerNodeExecutionConfig const & other);
  ~SafetyCheckerNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_SafetyCheckerNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit SafetyCheckerNodeExecutionConfig(SwigObj_inworld_SafetyCheckerNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  SafetyCheckerNodeExecutionConfig& operator=(SafetyCheckerNodeExecutionConfig const&) = delete;
  SafetyCheckerNodeExecutionConfig(SafetyCheckerNodeExecutionConfig&& obj) = default;
  SafetyCheckerNodeExecutionConfig& operator=(SafetyCheckerNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_SafetyCheckerNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_SafetyCheckerNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class SafetyCheckerNode : public TypedNode_SafetyResult {
public:
  static SafetyCheckerNode null() { return SafetyCheckerNode{(SwigObj_inworld_SafetyCheckerNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_SafetyCheckerNode inworld_inworld_graphs_SafetyCheckerNode_Create__SWIG(std::string const& id, CreationContext const & arg2, SafetyCheckerNodeCreationConfig const & arg3, SafetyCheckerNodeExecutionConfig const& arg4);
  SafetyCheckerNode(SafetyCheckerNode const & other);
  ~SafetyCheckerNode() {
    if (swig_owns_self_) {
      inworld_SafetyCheckerNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit SafetyCheckerNode(SwigObj_inworld_SafetyCheckerNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_SafetyResult{(SwigObj_inworld_TypedNode_SafetyResult*)swig_self, swig_owns_self} {}
  SafetyCheckerNode& operator=(SafetyCheckerNode const&) = delete;
  SafetyCheckerNode(SafetyCheckerNode&& obj) = default;
  SafetyCheckerNode& operator=(SafetyCheckerNode&& obj) = default;
  SwigObj_inworld_SafetyCheckerNode* swig_self() const noexcept { return (SwigObj_inworld_SafetyCheckerNode*)TypedNode_SafetyResult::swig_self(); }
};

class StatusOr_SharedPtr_STTNode {
public:
  StatusOr_SharedPtr_STTNode();
  StatusOr_SharedPtr_STTNode(STTNode const& value);
  StatusOr_SharedPtr_STTNode(Status const & status);
  bool ok() const;
  Status status() const;
  STTNode value() const;
  StatusOr_SharedPtr_STTNode(StatusOr_SharedPtr_STTNode const & other);
  ~StatusOr_SharedPtr_STTNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_STTNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_STTNode(SwigObj_inworld_StatusOr_SharedPtr_STTNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_STTNode& operator=(StatusOr_SharedPtr_STTNode const&) = delete;
  StatusOr_SharedPtr_STTNode(StatusOr_SharedPtr_STTNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_STTNode& operator=(StatusOr_SharedPtr_STTNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_STTNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_STTNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_STTNode* swig_self_;
  bool swig_owns_self_;
};

class STTNodeExecutionConfig : public NodeExecutionConfig {
public:
  static STTNodeExecutionConfig null() { return STTNodeExecutionConfig{(SwigObj_inworld_STTNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void stt_component_id(std::string const& stt_component_id);
  std::string stt_component_id() const;
  void speech_recognition_config(optional_SpeechRecognitionConfig * speech_recognition_config);
  optional_SpeechRecognitionConfig * speech_recognition_config() const;
  bool is_valid() const;
  STTNodeExecutionConfig();
  STTNodeExecutionConfig(STTNodeExecutionConfig const & other);
  ~STTNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_STTNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit STTNodeExecutionConfig(SwigObj_inworld_STTNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  STTNodeExecutionConfig& operator=(STTNodeExecutionConfig const&) = delete;
  STTNodeExecutionConfig(STTNodeExecutionConfig&& obj) = default;
  STTNodeExecutionConfig& operator=(STTNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_STTNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_STTNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class STTNode : public TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest {
public:
  static STTNode null() { return STTNode{(SwigObj_inworld_STTNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_STTNode inworld_inworld_graphs_STTNode_Create__SWIG(std::string const& id, STTNodeExecutionConfig const& arg2);
  STTNode(STTNode const & other);
  ~STTNode() {
    if (swig_owns_self_) {
      inworld_STTNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit STTNode(SwigObj_inworld_STTNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest{(SwigObj_inworld_TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest*)swig_self, swig_owns_self} {}
  STTNode& operator=(STTNode const&) = delete;
  STTNode(STTNode&& obj) = default;
  STTNode& operator=(STTNode&& obj) = default;
  SwigObj_inworld_STTNode* swig_self() const noexcept { return (SwigObj_inworld_STTNode*)TypedNode_Text_Variant_Audio_DataStream_AudioChunk_STTRequest::swig_self(); }
};

class StatusOr_SharedPtr_TextAggregatorNode {
public:
  StatusOr_SharedPtr_TextAggregatorNode();
  StatusOr_SharedPtr_TextAggregatorNode(TextAggregatorNode const& value);
  StatusOr_SharedPtr_TextAggregatorNode(Status const & status);
  bool ok() const;
  Status status() const;
  TextAggregatorNode value() const;
  StatusOr_SharedPtr_TextAggregatorNode(StatusOr_SharedPtr_TextAggregatorNode const & other);
  ~StatusOr_SharedPtr_TextAggregatorNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_TextAggregatorNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_TextAggregatorNode(SwigObj_inworld_StatusOr_SharedPtr_TextAggregatorNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_TextAggregatorNode& operator=(StatusOr_SharedPtr_TextAggregatorNode const&) = delete;
  StatusOr_SharedPtr_TextAggregatorNode(StatusOr_SharedPtr_TextAggregatorNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_TextAggregatorNode& operator=(StatusOr_SharedPtr_TextAggregatorNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_TextAggregatorNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_TextAggregatorNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_TextAggregatorNode* swig_self_;
  bool swig_owns_self_;
};

class TextAggregatorNode : public TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse {
public:
  static TextAggregatorNode null() { return TextAggregatorNode{(SwigObj_inworld_TextAggregatorNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_TextAggregatorNode inworld_inworld_graphs_TextAggregatorNode_Create__SWIG(std::string const& id, NodeExecutionConfig const& arg2);
  TextAggregatorNode(TextAggregatorNode const & other);
  ~TextAggregatorNode() {
    if (swig_owns_self_) {
      inworld_TextAggregatorNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TextAggregatorNode(SwigObj_inworld_TextAggregatorNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse{(SwigObj_inworld_TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse*)swig_self, swig_owns_self} {}
  TextAggregatorNode& operator=(TextAggregatorNode const&) = delete;
  TextAggregatorNode(TextAggregatorNode&& obj) = default;
  TextAggregatorNode& operator=(TextAggregatorNode&& obj) = default;
  SwigObj_inworld_TextAggregatorNode* swig_self() const noexcept { return (SwigObj_inworld_TextAggregatorNode*)TypedNode_Text_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse::swig_self(); }
};

class StatusOr_SharedPtr_TextChunkingNode {
public:
  StatusOr_SharedPtr_TextChunkingNode();
  StatusOr_SharedPtr_TextChunkingNode(TextChunkingNode const& value);
  StatusOr_SharedPtr_TextChunkingNode(Status const & status);
  bool ok() const;
  Status status() const;
  TextChunkingNode value() const;
  StatusOr_SharedPtr_TextChunkingNode(StatusOr_SharedPtr_TextChunkingNode const & other);
  ~StatusOr_SharedPtr_TextChunkingNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_TextChunkingNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_TextChunkingNode(SwigObj_inworld_StatusOr_SharedPtr_TextChunkingNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_TextChunkingNode& operator=(StatusOr_SharedPtr_TextChunkingNode const&) = delete;
  StatusOr_SharedPtr_TextChunkingNode(StatusOr_SharedPtr_TextChunkingNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_TextChunkingNode& operator=(StatusOr_SharedPtr_TextChunkingNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_TextChunkingNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_TextChunkingNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_TextChunkingNode* swig_self_;
  bool swig_owns_self_;
};

class TextChunkingNodeExecutionConfig : public NodeExecutionConfig {
public:
  static TextChunkingNodeExecutionConfig null() { return TextChunkingNodeExecutionConfig{(SwigObj_inworld_TextChunkingNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void min_chunk_length(optional_int * min_chunk_length);
  optional_int * min_chunk_length() const;
  bool is_valid() const;
  TextChunkingNodeExecutionConfig();
  TextChunkingNodeExecutionConfig(TextChunkingNodeExecutionConfig const & other);
  ~TextChunkingNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_TextChunkingNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TextChunkingNodeExecutionConfig(SwigObj_inworld_TextChunkingNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  TextChunkingNodeExecutionConfig& operator=(TextChunkingNodeExecutionConfig const&) = delete;
  TextChunkingNodeExecutionConfig(TextChunkingNodeExecutionConfig&& obj) = default;
  TextChunkingNodeExecutionConfig& operator=(TextChunkingNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_TextChunkingNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_TextChunkingNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class TextChunkingNode : public TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse {
public:
  static TextChunkingNode null() { return TextChunkingNode{(SwigObj_inworld_TextChunkingNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_TextChunkingNode inworld_inworld_graphs_TextChunkingNode_Create__SWIG(std::string const& id, TextChunkingNodeExecutionConfig const& arg2);
  TextChunkingNode(TextChunkingNode const & other);
  ~TextChunkingNode() {
    if (swig_owns_self_) {
      inworld_TextChunkingNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TextChunkingNode(SwigObj_inworld_TextChunkingNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse{(SwigObj_inworld_TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse*)swig_self, swig_owns_self} {}
  TextChunkingNode& operator=(TextChunkingNode const&) = delete;
  TextChunkingNode(TextChunkingNode&& obj) = default;
  TextChunkingNode& operator=(TextChunkingNode&& obj) = default;
  SwigObj_inworld_TextChunkingNode* swig_self() const noexcept { return (SwigObj_inworld_TextChunkingNode*)TypedNode_DataStream_String_Variant_Text_DataStream_String_LLMCompletionResponse_LLMChatResponse::swig_self(); }
};

class TypedNode_ClassificationResult : public TypedNodeBase {
public:
  static TypedNode_ClassificationResult null() { return TypedNode_ClassificationResult{(SwigObj_inworld_TypedNode_ClassificationResult*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  ~TypedNode_ClassificationResult() {
    if (swig_owns_self_) {
      inworld_TypedNode_ClassificationResult_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TypedNode_ClassificationResult(SwigObj_inworld_TypedNode_ClassificationResult* swig_self, bool swig_owns_self = true) noexcept : TypedNodeBase{(SwigObj_inworld_TypedNodeBase*)swig_self, swig_owns_self} {}
  TypedNode_ClassificationResult(TypedNode_ClassificationResult const&) = delete;
  TypedNode_ClassificationResult& operator=(TypedNode_ClassificationResult const&) = delete;
  TypedNode_ClassificationResult(TypedNode_ClassificationResult&& obj) = default;
  TypedNode_ClassificationResult& operator=(TypedNode_ClassificationResult&& obj) = default;
  SwigObj_inworld_TypedNode_ClassificationResult* swig_self() const noexcept { return (SwigObj_inworld_TypedNode_ClassificationResult*)TypedNodeBase::swig_self(); }
};

class StatusOr_SharedPtr_TextClassifierNode {
public:
  StatusOr_SharedPtr_TextClassifierNode();
  StatusOr_SharedPtr_TextClassifierNode(TextClassifierNode const& value);
  StatusOr_SharedPtr_TextClassifierNode(Status const & status);
  bool ok() const;
  Status status() const;
  TextClassifierNode value() const;
  StatusOr_SharedPtr_TextClassifierNode(StatusOr_SharedPtr_TextClassifierNode const & other);
  ~StatusOr_SharedPtr_TextClassifierNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_TextClassifierNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_TextClassifierNode(SwigObj_inworld_StatusOr_SharedPtr_TextClassifierNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_TextClassifierNode& operator=(StatusOr_SharedPtr_TextClassifierNode const&) = delete;
  StatusOr_SharedPtr_TextClassifierNode(StatusOr_SharedPtr_TextClassifierNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_TextClassifierNode& operator=(StatusOr_SharedPtr_TextClassifierNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_TextClassifierNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_TextClassifierNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_TextClassifierNode* swig_self_;
  bool swig_owns_self_;
};

class StatusOr_SharedPtr_ClassificationResult {
public:
  StatusOr_SharedPtr_ClassificationResult();
  StatusOr_SharedPtr_ClassificationResult(ClassificationResult const& value);
  StatusOr_SharedPtr_ClassificationResult(Status const & status);
  bool ok() const;
  Status status() const;
  ClassificationResult value() const;
  StatusOr_SharedPtr_ClassificationResult(StatusOr_SharedPtr_ClassificationResult const & other);
  ~StatusOr_SharedPtr_ClassificationResult() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_ClassificationResult_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_ClassificationResult(SwigObj_inworld_StatusOr_SharedPtr_ClassificationResult* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_ClassificationResult& operator=(StatusOr_SharedPtr_ClassificationResult const&) = delete;
  StatusOr_SharedPtr_ClassificationResult(StatusOr_SharedPtr_ClassificationResult&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_ClassificationResult& operator=(StatusOr_SharedPtr_ClassificationResult&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_ClassificationResult_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_ClassificationResult* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_ClassificationResult* swig_self_;
  bool swig_owns_self_;
};

class TextClassifierNodeCreationConfig {
public:
  void embedder_component_id(std::string const& embedder_component_id);
  std::string embedder_component_id() const;
  void classifier_config(TextClassifierCreationConfig * classifier_config);
  TextClassifierCreationConfig * classifier_config() const;
  TextClassifierNodeCreationConfig();
  TextClassifierNodeCreationConfig(TextClassifierNodeCreationConfig const & other);
  ~TextClassifierNodeCreationConfig() {
    if (swig_owns_self_)
      inworld_TextClassifierNodeCreationConfig_delete(swig_self_);
  }

  explicit TextClassifierNodeCreationConfig(SwigObj_inworld_TextClassifierNodeCreationConfig* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  TextClassifierNodeCreationConfig& operator=(TextClassifierNodeCreationConfig const&) = delete;
  TextClassifierNodeCreationConfig(TextClassifierNodeCreationConfig&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  TextClassifierNodeCreationConfig& operator=(TextClassifierNodeCreationConfig&& obj) noexcept {
    if (swig_owns_self_)
      inworld_TextClassifierNodeCreationConfig_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_TextClassifierNodeCreationConfig* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_TextClassifierNodeCreationConfig* swig_self_;
  bool swig_owns_self_;
};

class TextClassifierNodeExecutionConfig : public NodeExecutionConfig {
public:
  static TextClassifierNodeExecutionConfig null() { return TextClassifierNodeExecutionConfig{(SwigObj_inworld_TextClassifierNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void classifier_config(optional_TextClassifierConfig * classifier_config);
  optional_TextClassifierConfig * classifier_config() const;
  bool is_valid() const;
  TextClassifierNodeExecutionConfig();
  TextClassifierNodeExecutionConfig(TextClassifierNodeExecutionConfig const & other);
  ~TextClassifierNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_TextClassifierNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TextClassifierNodeExecutionConfig(SwigObj_inworld_TextClassifierNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  TextClassifierNodeExecutionConfig& operator=(TextClassifierNodeExecutionConfig const&) = delete;
  TextClassifierNodeExecutionConfig(TextClassifierNodeExecutionConfig&& obj) = default;
  TextClassifierNodeExecutionConfig& operator=(TextClassifierNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_TextClassifierNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_TextClassifierNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class TextClassifierNode : public TypedNode_ClassificationResult {
public:
  static TextClassifierNode null() { return TextClassifierNode{(SwigObj_inworld_TextClassifierNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  virtual ~TextClassifierNode() {
    if (swig_owns_self_) {
      inworld_TextClassifierNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }
  static StatusOr_SharedPtr_TextClassifierNode Create(std::string const& id, CreationContext const & arg2, TextClassifierNodeCreationConfig const & arg3, TextClassifierNodeExecutionConfig const & arg4);
  bool is_valid() const;
  TextClassifierNode(TextClassifierNode const & other);

  explicit TextClassifierNode(SwigObj_inworld_TextClassifierNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_ClassificationResult{(SwigObj_inworld_TypedNode_ClassificationResult*)swig_self, swig_owns_self} {}
  TextClassifierNode& operator=(TextClassifierNode const&) = delete;
  TextClassifierNode(TextClassifierNode&& obj) = default;
  TextClassifierNode& operator=(TextClassifierNode&& obj) = default;
  SwigObj_inworld_TextClassifierNode* swig_self() const noexcept { return (SwigObj_inworld_TextClassifierNode*)TypedNode_ClassificationResult::swig_self(); }
};

class StatusOr_SharedPtr_TTSNode {
public:
  StatusOr_SharedPtr_TTSNode();
  StatusOr_SharedPtr_TTSNode(TTSNode const& value);
  StatusOr_SharedPtr_TTSNode(Status const & status);
  bool ok() const;
  Status status() const;
  TTSNode value() const;
  StatusOr_SharedPtr_TTSNode(StatusOr_SharedPtr_TTSNode const & other);
  ~StatusOr_SharedPtr_TTSNode() {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_TTSNode_delete(swig_self_);
  }

  explicit StatusOr_SharedPtr_TTSNode(SwigObj_inworld_StatusOr_SharedPtr_TTSNode* swig_self, bool swig_owns_self = true) noexcept : swig_self_{swig_self}, swig_owns_self_{swig_owns_self} {}
  StatusOr_SharedPtr_TTSNode& operator=(StatusOr_SharedPtr_TTSNode const&) = delete;
  StatusOr_SharedPtr_TTSNode(StatusOr_SharedPtr_TTSNode&& obj) noexcept : swig_self_{obj.swig_self_}, swig_owns_self_{obj.swig_owns_self_} { obj.swig_owns_self_ = false; }
  StatusOr_SharedPtr_TTSNode& operator=(StatusOr_SharedPtr_TTSNode&& obj) noexcept {
    if (swig_owns_self_)
      inworld_StatusOr_SharedPtr_TTSNode_delete(swig_self_);
    swig_self_ = obj.swig_self_;
    swig_owns_self_ = obj.swig_owns_self_;
    obj.swig_owns_self_ = false;
    return *this;
  }
  SwigObj_inworld_StatusOr_SharedPtr_TTSNode* swig_self() const noexcept { return swig_self_; }
  SwigObj_inworld_StatusOr_SharedPtr_TTSNode* swig_self_;
  bool swig_owns_self_;
};

class TTSNodeExecutionConfig : public NodeExecutionConfig {
public:
  static TTSNodeExecutionConfig null() { return TTSNodeExecutionConfig{(SwigObj_inworld_TTSNodeExecutionConfig*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  void tts_component_id(std::string const& tts_component_id);
  std::string tts_component_id() const;
  void voice(Voice * voice);
  Voice * voice() const;
  void synthesis_config(optional_SpeechSynthesisConfig * synthesis_config);
  optional_SpeechSynthesisConfig * synthesis_config() const;
  bool is_valid() const;
  TTSNodeExecutionConfig();
  TTSNodeExecutionConfig(TTSNodeExecutionConfig const & other);
  ~TTSNodeExecutionConfig() {
    if (swig_owns_self_) {
      inworld_TTSNodeExecutionConfig_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TTSNodeExecutionConfig(SwigObj_inworld_TTSNodeExecutionConfig* swig_self, bool swig_owns_self = true) noexcept : NodeExecutionConfig{(SwigObj_inworld_NodeExecutionConfig*)swig_self, swig_owns_self} {}
  TTSNodeExecutionConfig& operator=(TTSNodeExecutionConfig const&) = delete;
  TTSNodeExecutionConfig(TTSNodeExecutionConfig&& obj) = default;
  TTSNodeExecutionConfig& operator=(TTSNodeExecutionConfig&& obj) = default;
  SwigObj_inworld_TTSNodeExecutionConfig* swig_self() const noexcept { return (SwigObj_inworld_TTSNodeExecutionConfig*)NodeExecutionConfig::swig_self(); }
};

class TTSNode : public TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest {
public:
  static TTSNode null() { return TTSNode{(SwigObj_inworld_TTSNode*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  bool is_valid() const;
  static StatusOr_SharedPtr_TTSNode inworld_inworld_graphs_TTSNode_Create__SWIG(std::string const& id, TTSNodeExecutionConfig const& arg2);
  TTSNode(TTSNode const & other);
  ~TTSNode() {
    if (swig_owns_self_) {
      inworld_TTSNode_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit TTSNode(SwigObj_inworld_TTSNode* swig_self, bool swig_owns_self = true) noexcept : TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest{(SwigObj_inworld_TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest*)swig_self, swig_owns_self} {}
  TTSNode& operator=(TTSNode const&) = delete;
  TTSNode(TTSNode&& obj) = default;
  TTSNode& operator=(TTSNode&& obj) = default;
  SwigObj_inworld_TTSNode* swig_self() const noexcept { return (SwigObj_inworld_TTSNode*)TypedNode_DataStream_TTSOutput_Variant_Text_DataStream_String_TTSRequest::swig_self(); }
};

class MemoryState : public BaseData {
public:
  static MemoryState null() { return MemoryState{(SwigObj_inworld_MemoryState*)nullptr, false}; }
  explicit operator bool() const { return swig_self_ != nullptr; }
  MemoryState();
  MemoryState(MemorySnapshot const& memory_snapshot);
  MemorySnapshot memory_snapshot() const;
  bool is_valid() const;
  std::string GetJson();
  MemoryState(MemoryState const & other);
  ~MemoryState() {
    if (swig_owns_self_) {
      inworld_MemoryState_delete(swig_self());
      swig_owns_self_ = false;
    }
  }

  explicit MemoryState(SwigObj_inworld_MemoryState* swig_self, bool swig_owns_self = true) noexcept : BaseData{(SwigObj_inworld_BaseData*)swig_self, swig_owns_self} {}
  MemoryState& operator=(MemoryState const&) = delete;
  MemoryState(MemoryState&& obj) = default;
  MemoryState& operator=(MemoryState&& obj) = default;
  SwigObj_inworld_MemoryState* swig_self() const noexcept { return (SwigObj_inworld_MemoryState*)BaseData::swig_self(); }
};


inline Status InitializeRegistries() {
  auto swig_cres = inworld_InitializeRegistries();
  return Status{swig_cres, true};
}
inline bool Status::ok() const { return inworld_Status_ok(swig_self()); }
inline Status Status::inworld_absl_Status_createStatus__SWIG(StatusCode code, std::string const& arg2) {
  auto swig_cres = inworld_Status_createStatus((inworld_StatusCode)code, (&arg2)->c_str());
  return Status{swig_cres, true};
}
inline std::string Status::ToString() const {
  auto swig_cres = inworld_Status_ToString(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline Status::Status() : Status{inworld_Status_new()} {}
inline Status::Status(Status const & other) : Status{inworld_Status_copy(other.swig_self())} {}
inline StatusOr_opaque::StatusOr_opaque() : StatusOr_opaque{inworld_StatusOr_opaque_new()} {}
inline StatusOr_opaque::StatusOr_opaque(void ** value) : StatusOr_opaque{inworld_StatusOr_opaque_new_rcpv(value)} {}
inline StatusOr_opaque::StatusOr_opaque(Status const & status) : StatusOr_opaque{inworld_StatusOr_opaque_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_opaque::ok() const { return inworld_StatusOr_opaque_ok(swig_self()); }
inline Status StatusOr_opaque::status() const {
  auto swig_cres = inworld_StatusOr_opaque_status(swig_self());
  return Status{swig_cres, false};
}
inline void * StatusOr_opaque::value() const { return inworld_StatusOr_opaque_value(swig_self()); }
inline StatusOr_opaque::StatusOr_opaque(StatusOr_opaque const & other) : StatusOr_opaque{inworld_StatusOr_opaque_copy(other.swig_self())} {}
inline StatusOr_int::StatusOr_int() : StatusOr_int{inworld_StatusOr_int_new()} {}
inline StatusOr_int::StatusOr_int(int value) : StatusOr_int{inworld_StatusOr_int_new_rci(value)} {}
inline StatusOr_int::StatusOr_int(Status const & status) : StatusOr_int{inworld_StatusOr_int_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_int::ok() const { return inworld_StatusOr_int_ok(swig_self()); }
inline Status StatusOr_int::status() const {
  auto swig_cres = inworld_StatusOr_int_status(swig_self());
  return Status{swig_cres, false};
}
inline int StatusOr_int::value() const { return inworld_StatusOr_int_value(swig_self()); }
inline StatusOr_int::StatusOr_int(StatusOr_int const & other) : StatusOr_int{inworld_StatusOr_int_copy(other.swig_self())} {}
inline StatusOr_string::StatusOr_string() : StatusOr_string{inworld_StatusOr_string_new()} {}
inline StatusOr_string::StatusOr_string(std::string const& value) : StatusOr_string{inworld_StatusOr_string_new_rcstd_string((&value)->c_str())} {}
inline StatusOr_string::StatusOr_string(Status const & status) : StatusOr_string{inworld_StatusOr_string_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_string::ok() const { return inworld_StatusOr_string_ok(swig_self()); }
inline Status StatusOr_string::status() const {
  auto swig_cres = inworld_StatusOr_string_status(swig_self());
  return Status{swig_cres, false};
}
inline std::string StatusOr_string::value() const {
  auto swig_cres = inworld_StatusOr_string_value(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline StatusOr_string::StatusOr_string(StatusOr_string const & other) : StatusOr_string{inworld_StatusOr_string_copy(other.swig_self())} {}
inline StatusOr_vector_string::StatusOr_vector_string() : StatusOr_vector_string{inworld_StatusOr_vector_string_new()} {}
inline StatusOr_vector_string::StatusOr_vector_string(vector_string const & value) : StatusOr_vector_string{inworld_StatusOr_vector_string_new_rcstd_vector_Sl_std_string_Sg_(value.swig_self())} {}
inline StatusOr_vector_string::StatusOr_vector_string(Status const & status) : StatusOr_vector_string{inworld_StatusOr_vector_string_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_vector_string::ok() const { return inworld_StatusOr_vector_string_ok(swig_self()); }
inline Status StatusOr_vector_string::status() const {
  auto swig_cres = inworld_StatusOr_vector_string_status(swig_self());
  return Status{swig_cres, false};
}
inline vector_string StatusOr_vector_string::value() const {
  auto swig_cres = inworld_StatusOr_vector_string_value(swig_self());
  return vector_string{swig_cres, true};
}
inline StatusOr_vector_string::StatusOr_vector_string(StatusOr_vector_string const & other) : StatusOr_vector_string{inworld_StatusOr_vector_string_copy(other.swig_self())} {}
inline StatusOr_vector_float::StatusOr_vector_float() : StatusOr_vector_float{inworld_StatusOr_vector_float_new()} {}
inline StatusOr_vector_float::StatusOr_vector_float(vector_float const & value) : StatusOr_vector_float{inworld_StatusOr_vector_float_new_rcstd_vector_Sl_float_Sg_(value.swig_self())} {}
inline StatusOr_vector_float::StatusOr_vector_float(Status const & status) : StatusOr_vector_float{inworld_StatusOr_vector_float_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_vector_float::ok() const { return inworld_StatusOr_vector_float_ok(swig_self()); }
inline Status StatusOr_vector_float::status() const {
  auto swig_cres = inworld_StatusOr_vector_float_status(swig_self());
  return Status{swig_cres, false};
}
inline vector_float StatusOr_vector_float::value() const {
  auto swig_cres = inworld_StatusOr_vector_float_value(swig_self());
  return vector_float{swig_cres, true};
}
inline StatusOr_vector_float::StatusOr_vector_float(StatusOr_vector_float const & other) : StatusOr_vector_float{inworld_StatusOr_vector_float_copy(other.swig_self())} {}
inline StatusOr_vector_vector_float::StatusOr_vector_vector_float() : StatusOr_vector_vector_float{inworld_StatusOr_vector_vector_float_new()} {}
inline StatusOr_vector_vector_float::StatusOr_vector_vector_float(vector_vector_float const & value) : StatusOr_vector_vector_float{inworld_StatusOr_vector_vector_float_new_rcstd_vector_Sl_std_vector_Sl_float_Sg__Sg_(value.swig_self())} {}
inline StatusOr_vector_vector_float::StatusOr_vector_vector_float(Status const & status) : StatusOr_vector_vector_float{inworld_StatusOr_vector_vector_float_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_vector_vector_float::ok() const { return inworld_StatusOr_vector_vector_float_ok(swig_self()); }
inline Status StatusOr_vector_vector_float::status() const {
  auto swig_cres = inworld_StatusOr_vector_vector_float_status(swig_self());
  return Status{swig_cres, false};
}
inline vector_vector_float StatusOr_vector_vector_float::value() const {
  auto swig_cres = inworld_StatusOr_vector_vector_float_value(swig_self());
  return vector_vector_float{swig_cres, true};
}
inline StatusOr_vector_vector_float::StatusOr_vector_vector_float(StatusOr_vector_vector_float const & other) : StatusOr_vector_vector_float{inworld_StatusOr_vector_vector_float_copy(other.swig_self())} {}
inline StatusOr_AudioChunk::StatusOr_AudioChunk() : StatusOr_AudioChunk{inworld_StatusOr_AudioChunk_new()} {}
inline StatusOr_AudioChunk::StatusOr_AudioChunk(AudioChunk const & value) : StatusOr_AudioChunk{inworld_StatusOr_AudioChunk_new_rcinworld_AudioChunk(value.swig_self())} {}
inline StatusOr_AudioChunk::StatusOr_AudioChunk(Status const & status) : StatusOr_AudioChunk{inworld_StatusOr_AudioChunk_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_AudioChunk::ok() const { return inworld_StatusOr_AudioChunk_ok(swig_self()); }
inline Status StatusOr_AudioChunk::status() const {
  auto swig_cres = inworld_StatusOr_AudioChunk_status(swig_self());
  return Status{swig_cres, false};
}
inline AudioChunk StatusOr_AudioChunk::value() const {
  auto swig_cres = inworld_StatusOr_AudioChunk_value(swig_self());
  return AudioChunk{swig_cres, true};
}
inline StatusOr_AudioChunk::StatusOr_AudioChunk(StatusOr_AudioChunk const & other) : StatusOr_AudioChunk{inworld_StatusOr_AudioChunk_copy(other.swig_self())} {}
inline StatusOr_Content::StatusOr_Content() : StatusOr_Content{inworld_StatusOr_Content_new()} {}
inline StatusOr_Content::StatusOr_Content(Content const & value) : StatusOr_Content{inworld_StatusOr_Content_new_rcinworld_Content(value.swig_self())} {}
inline StatusOr_Content::StatusOr_Content(Status const & status) : StatusOr_Content{inworld_StatusOr_Content_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_Content::ok() const { return inworld_StatusOr_Content_ok(swig_self()); }
inline Status StatusOr_Content::status() const {
  auto swig_cres = inworld_StatusOr_Content_status(swig_self());
  return Status{swig_cres, false};
}
inline Content StatusOr_Content::value() const {
  auto swig_cres = inworld_StatusOr_Content_value(swig_self());
  return Content{swig_cres, true};
}
inline StatusOr_Content::StatusOr_Content(StatusOr_Content const & other) : StatusOr_Content{inworld_StatusOr_Content_copy(other.swig_self())} {}
inline StatusOr_KnowledgeCollection::StatusOr_KnowledgeCollection() : StatusOr_KnowledgeCollection{inworld_StatusOr_KnowledgeCollection_new()} {}
inline StatusOr_KnowledgeCollection::StatusOr_KnowledgeCollection(KnowledgeCollection const & value) : StatusOr_KnowledgeCollection{inworld_StatusOr_KnowledgeCollection_new_rcinworld_KnowledgeCollection(value.swig_self())} {}
inline StatusOr_KnowledgeCollection::StatusOr_KnowledgeCollection(Status const & status) : StatusOr_KnowledgeCollection{inworld_StatusOr_KnowledgeCollection_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_KnowledgeCollection::ok() const { return inworld_StatusOr_KnowledgeCollection_ok(swig_self()); }
inline Status StatusOr_KnowledgeCollection::status() const {
  auto swig_cres = inworld_StatusOr_KnowledgeCollection_status(swig_self());
  return Status{swig_cres, false};
}
inline KnowledgeCollection StatusOr_KnowledgeCollection::value() const {
  auto swig_cres = inworld_StatusOr_KnowledgeCollection_value(swig_self());
  return KnowledgeCollection{swig_cres, true};
}
inline StatusOr_KnowledgeCollection::StatusOr_KnowledgeCollection(StatusOr_KnowledgeCollection const & other) : StatusOr_KnowledgeCollection{inworld_StatusOr_KnowledgeCollection_copy(other.swig_self())} {}
inline StatusOr_MemorySnapshot::StatusOr_MemorySnapshot() : StatusOr_MemorySnapshot{inworld_StatusOr_MemorySnapshot_new()} {}
inline StatusOr_MemorySnapshot::StatusOr_MemorySnapshot(MemorySnapshot const & value) : StatusOr_MemorySnapshot{inworld_StatusOr_MemorySnapshot_new_rcinworld_MemorySnapshot(value.swig_self())} {}
inline StatusOr_MemorySnapshot::StatusOr_MemorySnapshot(Status const & status) : StatusOr_MemorySnapshot{inworld_StatusOr_MemorySnapshot_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_MemorySnapshot::ok() const { return inworld_StatusOr_MemorySnapshot_ok(swig_self()); }
inline Status StatusOr_MemorySnapshot::status() const {
  auto swig_cres = inworld_StatusOr_MemorySnapshot_status(swig_self());
  return Status{swig_cres, false};
}
inline MemorySnapshot StatusOr_MemorySnapshot::value() const {
  auto swig_cres = inworld_StatusOr_MemorySnapshot_value(swig_self());
  return MemorySnapshot{swig_cres, true};
}
inline StatusOr_MemorySnapshot::StatusOr_MemorySnapshot(StatusOr_MemorySnapshot const & other) : StatusOr_MemorySnapshot{inworld_StatusOr_MemorySnapshot_copy(other.swig_self())} {}
inline StatusOr_CheckSafetyResponse::StatusOr_CheckSafetyResponse() : StatusOr_CheckSafetyResponse{inworld_StatusOr_CheckSafetyResponse_new()} {}
inline StatusOr_CheckSafetyResponse::StatusOr_CheckSafetyResponse(CheckSafetyResponse const & value) : StatusOr_CheckSafetyResponse{inworld_StatusOr_CheckSafetyResponse_new_rcinworld_CheckSafetyResponse(value.swig_self())} {}
inline StatusOr_CheckSafetyResponse::StatusOr_CheckSafetyResponse(Status const & status) : StatusOr_CheckSafetyResponse{inworld_StatusOr_CheckSafetyResponse_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_CheckSafetyResponse::ok() const { return inworld_StatusOr_CheckSafetyResponse_ok(swig_self()); }
inline Status StatusOr_CheckSafetyResponse::status() const {
  auto swig_cres = inworld_StatusOr_CheckSafetyResponse_status(swig_self());
  return Status{swig_cres, false};
}
inline CheckSafetyResponse StatusOr_CheckSafetyResponse::value() const {
  auto swig_cres = inworld_StatusOr_CheckSafetyResponse_value(swig_self());
  return CheckSafetyResponse{swig_cres, true};
}
inline StatusOr_CheckSafetyResponse::StatusOr_CheckSafetyResponse(StatusOr_CheckSafetyResponse const & other) : StatusOr_CheckSafetyResponse{inworld_StatusOr_CheckSafetyResponse_copy(other.swig_self())} {}
inline StatusOr_SilenceIntervals::StatusOr_SilenceIntervals() : StatusOr_SilenceIntervals{inworld_StatusOr_SilenceIntervals_new()} {}
inline StatusOr_SilenceIntervals::StatusOr_SilenceIntervals(SilenceIntervals const & value) : StatusOr_SilenceIntervals{inworld_StatusOr_SilenceIntervals_new_rcstd_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg_(value.swig_self())} {}
inline StatusOr_SilenceIntervals::StatusOr_SilenceIntervals(Status const & status) : StatusOr_SilenceIntervals{inworld_StatusOr_SilenceIntervals_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SilenceIntervals::ok() const { return inworld_StatusOr_SilenceIntervals_ok(swig_self()); }
inline Status StatusOr_SilenceIntervals::status() const {
  auto swig_cres = inworld_StatusOr_SilenceIntervals_status(swig_self());
  return Status{swig_cres, false};
}
inline SilenceIntervals StatusOr_SilenceIntervals::value() const {
  auto swig_cres = inworld_StatusOr_SilenceIntervals_value(swig_self());
  return SilenceIntervals{swig_cres, true};
}
inline StatusOr_SilenceIntervals::StatusOr_SilenceIntervals(StatusOr_SilenceIntervals const & other) : StatusOr_SilenceIntervals{inworld_StatusOr_SilenceIntervals_copy(other.swig_self())} {}
inline StatusOr_vector_CompiledIntent::StatusOr_vector_CompiledIntent() : StatusOr_vector_CompiledIntent{inworld_StatusOr_vector_CompiledIntent_new()} {}
inline StatusOr_vector_CompiledIntent::StatusOr_vector_CompiledIntent(vector_CompiledIntent const & value) : StatusOr_vector_CompiledIntent{inworld_StatusOr_vector_CompiledIntent_new_rcstd_vector_Sl_inworld_CompiledIntent_Sg_(value.swig_self())} {}
inline StatusOr_vector_CompiledIntent::StatusOr_vector_CompiledIntent(Status const & status) : StatusOr_vector_CompiledIntent{inworld_StatusOr_vector_CompiledIntent_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_vector_CompiledIntent::ok() const { return inworld_StatusOr_vector_CompiledIntent_ok(swig_self()); }
inline Status StatusOr_vector_CompiledIntent::status() const {
  auto swig_cres = inworld_StatusOr_vector_CompiledIntent_status(swig_self());
  return Status{swig_cres, false};
}
inline vector_CompiledIntent StatusOr_vector_CompiledIntent::value() const {
  auto swig_cres = inworld_StatusOr_vector_CompiledIntent_value(swig_self());
  return vector_CompiledIntent{swig_cres, true};
}
inline StatusOr_vector_CompiledIntent::StatusOr_vector_CompiledIntent(StatusOr_vector_CompiledIntent const & other) : StatusOr_vector_CompiledIntent{inworld_StatusOr_vector_CompiledIntent_copy(other.swig_self())} {}
inline StatusOr_vector_IntentMatch::StatusOr_vector_IntentMatch() : StatusOr_vector_IntentMatch{inworld_StatusOr_vector_IntentMatch_new()} {}
inline StatusOr_vector_IntentMatch::StatusOr_vector_IntentMatch(vector_IntentMatch const & value) : StatusOr_vector_IntentMatch{inworld_StatusOr_vector_IntentMatch_new_rcstd_vector_Sl_inworld_IntentMatch_Sg_(value.swig_self())} {}
inline StatusOr_vector_IntentMatch::StatusOr_vector_IntentMatch(Status const & status) : StatusOr_vector_IntentMatch{inworld_StatusOr_vector_IntentMatch_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_vector_IntentMatch::ok() const { return inworld_StatusOr_vector_IntentMatch_ok(swig_self()); }
inline Status StatusOr_vector_IntentMatch::status() const {
  auto swig_cres = inworld_StatusOr_vector_IntentMatch_status(swig_self());
  return Status{swig_cres, false};
}
inline vector_IntentMatch StatusOr_vector_IntentMatch::value() const {
  auto swig_cres = inworld_StatusOr_vector_IntentMatch_value(swig_self());
  return vector_IntentMatch{swig_cres, true};
}
inline StatusOr_vector_IntentMatch::StatusOr_vector_IntentMatch(StatusOr_vector_IntentMatch const & other) : StatusOr_vector_IntentMatch{inworld_StatusOr_vector_IntentMatch_copy(other.swig_self())} {}
inline StatusOr_vector_EntityMatch::StatusOr_vector_EntityMatch() : StatusOr_vector_EntityMatch{inworld_StatusOr_vector_EntityMatch_new()} {}
inline StatusOr_vector_EntityMatch::StatusOr_vector_EntityMatch(vector_EntityMatch const & value) : StatusOr_vector_EntityMatch{inworld_StatusOr_vector_EntityMatch_new_rcstd_vector_Sl_inworld_EntityMatch_Sg_(value.swig_self())} {}
inline StatusOr_vector_EntityMatch::StatusOr_vector_EntityMatch(Status const & status) : StatusOr_vector_EntityMatch{inworld_StatusOr_vector_EntityMatch_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_vector_EntityMatch::ok() const { return inworld_StatusOr_vector_EntityMatch_ok(swig_self()); }
inline Status StatusOr_vector_EntityMatch::status() const {
  auto swig_cres = inworld_StatusOr_vector_EntityMatch_status(swig_self());
  return Status{swig_cres, false};
}
inline vector_EntityMatch StatusOr_vector_EntityMatch::value() const {
  auto swig_cres = inworld_StatusOr_vector_EntityMatch_value(swig_self());
  return vector_EntityMatch{swig_cres, true};
}
inline StatusOr_vector_EntityMatch::StatusOr_vector_EntityMatch(StatusOr_vector_EntityMatch const & other) : StatusOr_vector_EntityMatch{inworld_StatusOr_vector_EntityMatch_copy(other.swig_self())} {}
inline StatusOr_vector_PhraseMatch::StatusOr_vector_PhraseMatch() : StatusOr_vector_PhraseMatch{inworld_StatusOr_vector_PhraseMatch_new()} {}
inline StatusOr_vector_PhraseMatch::StatusOr_vector_PhraseMatch(vector_PhraseMatch const & value) : StatusOr_vector_PhraseMatch{inworld_StatusOr_vector_PhraseMatch_new_rcstd_vector_Sl_inworld_graphs_PhraseMatch_Sg_(value.swig_self())} {}
inline StatusOr_vector_PhraseMatch::StatusOr_vector_PhraseMatch(Status const & status) : StatusOr_vector_PhraseMatch{inworld_StatusOr_vector_PhraseMatch_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_vector_PhraseMatch::ok() const { return inworld_StatusOr_vector_PhraseMatch_ok(swig_self()); }
inline Status StatusOr_vector_PhraseMatch::status() const {
  auto swig_cres = inworld_StatusOr_vector_PhraseMatch_status(swig_self());
  return Status{swig_cres, false};
}
inline vector_PhraseMatch StatusOr_vector_PhraseMatch::value() const {
  auto swig_cres = inworld_StatusOr_vector_PhraseMatch_value(swig_self());
  return vector_PhraseMatch{swig_cres, true};
}
inline StatusOr_vector_PhraseMatch::StatusOr_vector_PhraseMatch(StatusOr_vector_PhraseMatch const & other) : StatusOr_vector_PhraseMatch{inworld_StatusOr_vector_PhraseMatch_copy(other.swig_self())} {}
inline StatusOr_LLMInterface::StatusOr_LLMInterface() : StatusOr_LLMInterface{inworld_StatusOr_LLMInterface_new()} {}
inline StatusOr_LLMInterface::StatusOr_LLMInterface(LLMInterface const& value) : StatusOr_LLMInterface{inworld_StatusOr_LLMInterface_new_rcstd_shared_ptr_Sl_inworld_LLMInterface_SS_const_Sg_(value.swig_self())} {}
inline StatusOr_LLMInterface::StatusOr_LLMInterface(Status const & status) : StatusOr_LLMInterface{inworld_StatusOr_LLMInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_LLMInterface::ok() const { return inworld_StatusOr_LLMInterface_ok(swig_self()); }
inline Status StatusOr_LLMInterface::status() const {
  auto swig_cres = inworld_StatusOr_LLMInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline LLMInterface StatusOr_LLMInterface::value() const {
  auto swig_cres = inworld_StatusOr_LLMInterface_value(swig_self());
  return LLMInterface{swig_cres, true};
}
inline StatusOr_LLMInterface::StatusOr_LLMInterface(StatusOr_LLMInterface const & other) : StatusOr_LLMInterface{inworld_StatusOr_LLMInterface_copy(other.swig_self())} {}
inline StatusOr_LLMRouting::StatusOr_LLMRouting() : StatusOr_LLMRouting{inworld_StatusOr_LLMRouting_new()} {}
inline StatusOr_LLMRouting::StatusOr_LLMRouting(LLMRouting const& value) : StatusOr_LLMRouting{inworld_StatusOr_LLMRouting_new_rcstd_shared_ptr_Sl_inworld_LLMRouting_SS_const_Sg_(value.swig_self())} {}
inline StatusOr_LLMRouting::StatusOr_LLMRouting(Status const & status) : StatusOr_LLMRouting{inworld_StatusOr_LLMRouting_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_LLMRouting::ok() const { return inworld_StatusOr_LLMRouting_ok(swig_self()); }
inline Status StatusOr_LLMRouting::status() const {
  auto swig_cres = inworld_StatusOr_LLMRouting_status(swig_self());
  return Status{swig_cres, false};
}
inline LLMRouting StatusOr_LLMRouting::value() const {
  auto swig_cres = inworld_StatusOr_LLMRouting_value(swig_self());
  return LLMRouting{swig_cres, true};
}
inline StatusOr_LLMRouting::StatusOr_LLMRouting(StatusOr_LLMRouting const & other) : StatusOr_LLMRouting{inworld_StatusOr_LLMRouting_copy(other.swig_self())} {}
inline StatusOr_STTInterface::StatusOr_STTInterface() : StatusOr_STTInterface{inworld_StatusOr_STTInterface_new()} {}
inline StatusOr_STTInterface::StatusOr_STTInterface(STTInterface const& value) : StatusOr_STTInterface{inworld_StatusOr_STTInterface_new_rcstd_shared_ptr_Sl_inworld_STTInterface_SS_const_Sg_(value.swig_self())} {}
inline StatusOr_STTInterface::StatusOr_STTInterface(Status const & status) : StatusOr_STTInterface{inworld_StatusOr_STTInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_STTInterface::ok() const { return inworld_StatusOr_STTInterface_ok(swig_self()); }
inline Status StatusOr_STTInterface::status() const {
  auto swig_cres = inworld_StatusOr_STTInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline STTInterface StatusOr_STTInterface::value() const {
  auto swig_cres = inworld_StatusOr_STTInterface_value(swig_self());
  return STTInterface{swig_cres, true};
}
inline StatusOr_STTInterface::StatusOr_STTInterface(StatusOr_STTInterface const & other) : StatusOr_STTInterface{inworld_StatusOr_STTInterface_copy(other.swig_self())} {}
inline StatusOr_StreamingSTTInterface::StatusOr_StreamingSTTInterface() : StatusOr_StreamingSTTInterface{inworld_StatusOr_StreamingSTTInterface_new()} {}
inline StatusOr_StreamingSTTInterface::StatusOr_StreamingSTTInterface(StreamingSTTInterface const& value) : StatusOr_StreamingSTTInterface{inworld_StatusOr_StreamingSTTInterface_new_rcstd_shared_ptr_Sl_inworld_StreamingSTTInterface_SS_const_Sg_(value.swig_self())} {}
inline StatusOr_StreamingSTTInterface::StatusOr_StreamingSTTInterface(Status const & status) : StatusOr_StreamingSTTInterface{inworld_StatusOr_StreamingSTTInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_StreamingSTTInterface::ok() const { return inworld_StatusOr_StreamingSTTInterface_ok(swig_self()); }
inline Status StatusOr_StreamingSTTInterface::status() const {
  auto swig_cres = inworld_StatusOr_StreamingSTTInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline StreamingSTTInterface StatusOr_StreamingSTTInterface::value() const {
  auto swig_cres = inworld_StatusOr_StreamingSTTInterface_value(swig_self());
  return StreamingSTTInterface{swig_cres, true};
}
inline StatusOr_StreamingSTTInterface::StatusOr_StreamingSTTInterface(StatusOr_StreamingSTTInterface const & other) : StatusOr_StreamingSTTInterface{inworld_StatusOr_StreamingSTTInterface_copy(other.swig_self())} {}
inline StatusOr_TTSInterface::StatusOr_TTSInterface() : StatusOr_TTSInterface{inworld_StatusOr_TTSInterface_new()} {}
inline StatusOr_TTSInterface::StatusOr_TTSInterface(TTSInterface const& value) : StatusOr_TTSInterface{inworld_StatusOr_TTSInterface_new_rcstd_shared_ptr_Sl_inworld_TTSInterface_SS_const_Sg_(value.swig_self())} {}
inline StatusOr_TTSInterface::StatusOr_TTSInterface(Status const & status) : StatusOr_TTSInterface{inworld_StatusOr_TTSInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_TTSInterface::ok() const { return inworld_StatusOr_TTSInterface_ok(swig_self()); }
inline Status StatusOr_TTSInterface::status() const {
  auto swig_cres = inworld_StatusOr_TTSInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline TTSInterface StatusOr_TTSInterface::value() const {
  auto swig_cres = inworld_StatusOr_TTSInterface_value(swig_self());
  return TTSInterface{swig_cres, true};
}
inline StatusOr_TTSInterface::StatusOr_TTSInterface(StatusOr_TTSInterface const & other) : StatusOr_TTSInterface{inworld_StatusOr_TTSInterface_copy(other.swig_self())} {}
inline StatusOr_VADInterface::StatusOr_VADInterface() : StatusOr_VADInterface{inworld_StatusOr_VADInterface_new()} {}
inline StatusOr_VADInterface::StatusOr_VADInterface(VADInterface const& value) : StatusOr_VADInterface{inworld_StatusOr_VADInterface_new_rcstd_shared_ptr_Sl_inworld_VADInterface_Sg_(value.swig_self())} {}
inline StatusOr_VADInterface::StatusOr_VADInterface(Status const & status) : StatusOr_VADInterface{inworld_StatusOr_VADInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_VADInterface::ok() const { return inworld_StatusOr_VADInterface_ok(swig_self()); }
inline Status StatusOr_VADInterface::status() const {
  auto swig_cres = inworld_StatusOr_VADInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline VADInterface StatusOr_VADInterface::value() const {
  auto swig_cres = inworld_StatusOr_VADInterface_value(swig_self());
  return VADInterface{swig_cres, true};
}
inline StatusOr_VADInterface::StatusOr_VADInterface(StatusOr_VADInterface const & other) : StatusOr_VADInterface{inworld_StatusOr_VADInterface_copy(other.swig_self())} {}
inline StatusOr_AECFilterInterface::StatusOr_AECFilterInterface() : StatusOr_AECFilterInterface{inworld_StatusOr_AECFilterInterface_new()} {}
inline StatusOr_AECFilterInterface::StatusOr_AECFilterInterface(AECFilterInterface const& value) : StatusOr_AECFilterInterface{inworld_StatusOr_AECFilterInterface_new_rcstd_shared_ptr_Sl_inworld_AECFilterInterface_Sg_(value.swig_self())} {}
inline StatusOr_AECFilterInterface::StatusOr_AECFilterInterface(Status const & status) : StatusOr_AECFilterInterface{inworld_StatusOr_AECFilterInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_AECFilterInterface::ok() const { return inworld_StatusOr_AECFilterInterface_ok(swig_self()); }
inline Status StatusOr_AECFilterInterface::status() const {
  auto swig_cres = inworld_StatusOr_AECFilterInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline AECFilterInterface StatusOr_AECFilterInterface::value() const {
  auto swig_cres = inworld_StatusOr_AECFilterInterface_value(swig_self());
  return AECFilterInterface{swig_cres, true};
}
inline StatusOr_AECFilterInterface::StatusOr_AECFilterInterface(StatusOr_AECFilterInterface const & other) : StatusOr_AECFilterInterface{inworld_StatusOr_AECFilterInterface_copy(other.swig_self())} {}
inline StatusOr_IntentCompilerInterface::StatusOr_IntentCompilerInterface() : StatusOr_IntentCompilerInterface{inworld_StatusOr_IntentCompilerInterface_new()} {}
inline StatusOr_IntentCompilerInterface::StatusOr_IntentCompilerInterface(IntentCompilerInterface const& value) : StatusOr_IntentCompilerInterface{inworld_StatusOr_IntentCompilerInterface_new_rcstd_shared_ptr_Sl_inworld_IntentCompilerInterface_Sg_(value.swig_self())} {}
inline StatusOr_IntentCompilerInterface::StatusOr_IntentCompilerInterface(Status const & status) : StatusOr_IntentCompilerInterface{inworld_StatusOr_IntentCompilerInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_IntentCompilerInterface::ok() const { return inworld_StatusOr_IntentCompilerInterface_ok(swig_self()); }
inline Status StatusOr_IntentCompilerInterface::status() const {
  auto swig_cres = inworld_StatusOr_IntentCompilerInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline IntentCompilerInterface StatusOr_IntentCompilerInterface::value() const {
  auto swig_cres = inworld_StatusOr_IntentCompilerInterface_value(swig_self());
  return IntentCompilerInterface{swig_cres, true};
}
inline StatusOr_IntentCompilerInterface::StatusOr_IntentCompilerInterface(StatusOr_IntentCompilerInterface const & other) : StatusOr_IntentCompilerInterface{inworld_StatusOr_IntentCompilerInterface_copy(other.swig_self())} {}
inline StatusOr_IntentMatcherInterface::StatusOr_IntentMatcherInterface() : StatusOr_IntentMatcherInterface{inworld_StatusOr_IntentMatcherInterface_new()} {}
inline StatusOr_IntentMatcherInterface::StatusOr_IntentMatcherInterface(IntentMatcherInterface const& value) : StatusOr_IntentMatcherInterface{inworld_StatusOr_IntentMatcherInterface_new_rcstd_shared_ptr_Sl_inworld_IntentMatcherInterface_Sg_(value.swig_self())} {}
inline StatusOr_IntentMatcherInterface::StatusOr_IntentMatcherInterface(Status const & status) : StatusOr_IntentMatcherInterface{inworld_StatusOr_IntentMatcherInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_IntentMatcherInterface::ok() const { return inworld_StatusOr_IntentMatcherInterface_ok(swig_self()); }
inline Status StatusOr_IntentMatcherInterface::status() const {
  auto swig_cres = inworld_StatusOr_IntentMatcherInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline IntentMatcherInterface StatusOr_IntentMatcherInterface::value() const {
  auto swig_cres = inworld_StatusOr_IntentMatcherInterface_value(swig_self());
  return IntentMatcherInterface{swig_cres, true};
}
inline StatusOr_IntentMatcherInterface::StatusOr_IntentMatcherInterface(StatusOr_IntentMatcherInterface const & other) : StatusOr_IntentMatcherInterface{inworld_StatusOr_IntentMatcherInterface_copy(other.swig_self())} {}
inline StatusOr_KeywordMatcherInterface::StatusOr_KeywordMatcherInterface() : StatusOr_KeywordMatcherInterface{inworld_StatusOr_KeywordMatcherInterface_new()} {}
inline StatusOr_KeywordMatcherInterface::StatusOr_KeywordMatcherInterface(KeywordMatcherInterface const& value) : StatusOr_KeywordMatcherInterface{inworld_StatusOr_KeywordMatcherInterface_new_rcstd_shared_ptr_Sl_inworld_KeywordMatcherInterface_Sg_(value.swig_self())} {}
inline StatusOr_KeywordMatcherInterface::StatusOr_KeywordMatcherInterface(Status const & status) : StatusOr_KeywordMatcherInterface{inworld_StatusOr_KeywordMatcherInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_KeywordMatcherInterface::ok() const { return inworld_StatusOr_KeywordMatcherInterface_ok(swig_self()); }
inline Status StatusOr_KeywordMatcherInterface::status() const {
  auto swig_cres = inworld_StatusOr_KeywordMatcherInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline KeywordMatcherInterface StatusOr_KeywordMatcherInterface::value() const {
  auto swig_cres = inworld_StatusOr_KeywordMatcherInterface_value(swig_self());
  return KeywordMatcherInterface{swig_cres, true};
}
inline StatusOr_KeywordMatcherInterface::StatusOr_KeywordMatcherInterface(StatusOr_KeywordMatcherInterface const & other) : StatusOr_KeywordMatcherInterface{inworld_StatusOr_KeywordMatcherInterface_copy(other.swig_self())} {}
inline StatusOr_KeywordMatcherResponse::StatusOr_KeywordMatcherResponse() : StatusOr_KeywordMatcherResponse{inworld_StatusOr_KeywordMatcherResponse_new()} {}
inline StatusOr_KeywordMatcherResponse::StatusOr_KeywordMatcherResponse(KeywordMatcherResponse const & value) : StatusOr_KeywordMatcherResponse{inworld_StatusOr_KeywordMatcherResponse_new_rcinworld_KeywordMatcherResponse(value.swig_self())} {}
inline StatusOr_KeywordMatcherResponse::StatusOr_KeywordMatcherResponse(Status const & status) : StatusOr_KeywordMatcherResponse{inworld_StatusOr_KeywordMatcherResponse_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_KeywordMatcherResponse::ok() const { return inworld_StatusOr_KeywordMatcherResponse_ok(swig_self()); }
inline Status StatusOr_KeywordMatcherResponse::status() const {
  auto swig_cres = inworld_StatusOr_KeywordMatcherResponse_status(swig_self());
  return Status{swig_cres, false};
}
inline KeywordMatcherResponse StatusOr_KeywordMatcherResponse::value() const {
  auto swig_cres = inworld_StatusOr_KeywordMatcherResponse_value(swig_self());
  return KeywordMatcherResponse{swig_cres, true};
}
inline StatusOr_KeywordMatcherResponse::StatusOr_KeywordMatcherResponse(StatusOr_KeywordMatcherResponse const & other) : StatusOr_KeywordMatcherResponse{inworld_StatusOr_KeywordMatcherResponse_copy(other.swig_self())} {}
inline StatusOr_KnowledgeInterface::StatusOr_KnowledgeInterface() : StatusOr_KnowledgeInterface{inworld_StatusOr_KnowledgeInterface_new()} {}
inline StatusOr_KnowledgeInterface::StatusOr_KnowledgeInterface(KnowledgeInterface const& value) : StatusOr_KnowledgeInterface{inworld_StatusOr_KnowledgeInterface_new_rcstd_shared_ptr_Sl_inworld_KnowledgeInterface_SS_const_Sg_(value.swig_self())} {}
inline StatusOr_KnowledgeInterface::StatusOr_KnowledgeInterface(Status const & status) : StatusOr_KnowledgeInterface{inworld_StatusOr_KnowledgeInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_KnowledgeInterface::ok() const { return inworld_StatusOr_KnowledgeInterface_ok(swig_self()); }
inline Status StatusOr_KnowledgeInterface::status() const {
  auto swig_cres = inworld_StatusOr_KnowledgeInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline KnowledgeInterface StatusOr_KnowledgeInterface::value() const {
  auto swig_cres = inworld_StatusOr_KnowledgeInterface_value(swig_self());
  return KnowledgeInterface{swig_cres, true};
}
inline StatusOr_KnowledgeInterface::StatusOr_KnowledgeInterface(StatusOr_KnowledgeInterface const & other) : StatusOr_KnowledgeInterface{inworld_StatusOr_KnowledgeInterface_copy(other.swig_self())} {}
inline StatusOr_KnowledgeRetrieverInterface::StatusOr_KnowledgeRetrieverInterface() : StatusOr_KnowledgeRetrieverInterface{inworld_StatusOr_KnowledgeRetrieverInterface_new()} {}
inline StatusOr_KnowledgeRetrieverInterface::StatusOr_KnowledgeRetrieverInterface(KnowledgeRetrieverInterface const& value) : StatusOr_KnowledgeRetrieverInterface{inworld_StatusOr_KnowledgeRetrieverInterface_new_rcstd_shared_ptr_Sl_inworld_KnowledgeRetrieverInterface_Sg_(value.swig_self())} {}
inline StatusOr_KnowledgeRetrieverInterface::StatusOr_KnowledgeRetrieverInterface(Status const & status) : StatusOr_KnowledgeRetrieverInterface{inworld_StatusOr_KnowledgeRetrieverInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_KnowledgeRetrieverInterface::ok() const { return inworld_StatusOr_KnowledgeRetrieverInterface_ok(swig_self()); }
inline Status StatusOr_KnowledgeRetrieverInterface::status() const {
  auto swig_cres = inworld_StatusOr_KnowledgeRetrieverInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline KnowledgeRetrieverInterface StatusOr_KnowledgeRetrieverInterface::value() const {
  auto swig_cres = inworld_StatusOr_KnowledgeRetrieverInterface_value(swig_self());
  return KnowledgeRetrieverInterface{swig_cres, true};
}
inline StatusOr_KnowledgeRetrieverInterface::StatusOr_KnowledgeRetrieverInterface(StatusOr_KnowledgeRetrieverInterface const & other) : StatusOr_KnowledgeRetrieverInterface{inworld_StatusOr_KnowledgeRetrieverInterface_copy(other.swig_self())} {}
inline StatusOr_MemoryInterface::StatusOr_MemoryInterface() : StatusOr_MemoryInterface{inworld_StatusOr_MemoryInterface_new()} {}
inline StatusOr_MemoryInterface::StatusOr_MemoryInterface(MemoryInterface const& value) : StatusOr_MemoryInterface{inworld_StatusOr_MemoryInterface_new_rcstd_shared_ptr_Sl_inworld_MemoryInterface_Sg_(value.swig_self())} {}
inline StatusOr_MemoryInterface::StatusOr_MemoryInterface(Status const & status) : StatusOr_MemoryInterface{inworld_StatusOr_MemoryInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_MemoryInterface::ok() const { return inworld_StatusOr_MemoryInterface_ok(swig_self()); }
inline Status StatusOr_MemoryInterface::status() const {
  auto swig_cres = inworld_StatusOr_MemoryInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline MemoryInterface StatusOr_MemoryInterface::value() const {
  auto swig_cres = inworld_StatusOr_MemoryInterface_value(swig_self());
  return MemoryInterface{swig_cres, true};
}
inline StatusOr_MemoryInterface::StatusOr_MemoryInterface(StatusOr_MemoryInterface const & other) : StatusOr_MemoryInterface{inworld_StatusOr_MemoryInterface_copy(other.swig_self())} {}
inline StatusOr_SafetyCheckerInterface::StatusOr_SafetyCheckerInterface() : StatusOr_SafetyCheckerInterface{inworld_StatusOr_SafetyCheckerInterface_new()} {}
inline StatusOr_SafetyCheckerInterface::StatusOr_SafetyCheckerInterface(SafetyCheckerInterface const& value) : StatusOr_SafetyCheckerInterface{inworld_StatusOr_SafetyCheckerInterface_new_rcstd_shared_ptr_Sl_inworld_SafetyCheckerInterface_Sg_(value.swig_self())} {}
inline StatusOr_SafetyCheckerInterface::StatusOr_SafetyCheckerInterface(Status const & status) : StatusOr_SafetyCheckerInterface{inworld_StatusOr_SafetyCheckerInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SafetyCheckerInterface::ok() const { return inworld_StatusOr_SafetyCheckerInterface_ok(swig_self()); }
inline Status StatusOr_SafetyCheckerInterface::status() const {
  auto swig_cres = inworld_StatusOr_SafetyCheckerInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline SafetyCheckerInterface StatusOr_SafetyCheckerInterface::value() const {
  auto swig_cres = inworld_StatusOr_SafetyCheckerInterface_value(swig_self());
  return SafetyCheckerInterface{swig_cres, true};
}
inline StatusOr_SafetyCheckerInterface::StatusOr_SafetyCheckerInterface(StatusOr_SafetyCheckerInterface const & other) : StatusOr_SafetyCheckerInterface{inworld_StatusOr_SafetyCheckerInterface_copy(other.swig_self())} {}
inline StatusOr_TextEmbedderInterface::StatusOr_TextEmbedderInterface() : StatusOr_TextEmbedderInterface{inworld_StatusOr_TextEmbedderInterface_new()} {}
inline StatusOr_TextEmbedderInterface::StatusOr_TextEmbedderInterface(TextEmbedderInterface const& value) : StatusOr_TextEmbedderInterface{inworld_StatusOr_TextEmbedderInterface_new_rcstd_shared_ptr_Sl_inworld_TextEmbedderInterface_SS_const_Sg_(value.swig_self())} {}
inline StatusOr_TextEmbedderInterface::StatusOr_TextEmbedderInterface(Status const & status) : StatusOr_TextEmbedderInterface{inworld_StatusOr_TextEmbedderInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_TextEmbedderInterface::ok() const { return inworld_StatusOr_TextEmbedderInterface_ok(swig_self()); }
inline Status StatusOr_TextEmbedderInterface::status() const {
  auto swig_cres = inworld_StatusOr_TextEmbedderInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline TextEmbedderInterface StatusOr_TextEmbedderInterface::value() const {
  auto swig_cres = inworld_StatusOr_TextEmbedderInterface_value(swig_self());
  return TextEmbedderInterface{swig_cres, true};
}
inline StatusOr_TextEmbedderInterface::StatusOr_TextEmbedderInterface(StatusOr_TextEmbedderInterface const & other) : StatusOr_TextEmbedderInterface{inworld_StatusOr_TextEmbedderInterface_copy(other.swig_self())} {}
inline StatusOr_EmojiRemover::StatusOr_EmojiRemover() : StatusOr_EmojiRemover{inworld_StatusOr_EmojiRemover_new()} {}
inline StatusOr_EmojiRemover::StatusOr_EmojiRemover(EmojiRemover const& value) : StatusOr_EmojiRemover{inworld_StatusOr_EmojiRemover_new_rcstd_shared_ptr_Sl_inworld_EmojiRemover_Sg_(value.swig_self())} {}
inline StatusOr_EmojiRemover::StatusOr_EmojiRemover(Status const & status) : StatusOr_EmojiRemover{inworld_StatusOr_EmojiRemover_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_EmojiRemover::ok() const { return inworld_StatusOr_EmojiRemover_ok(swig_self()); }
inline Status StatusOr_EmojiRemover::status() const {
  auto swig_cres = inworld_StatusOr_EmojiRemover_status(swig_self());
  return Status{swig_cres, false};
}
inline EmojiRemover StatusOr_EmojiRemover::value() const {
  auto swig_cres = inworld_StatusOr_EmojiRemover_value(swig_self());
  return EmojiRemover{swig_cres, true};
}
inline StatusOr_EmojiRemover::StatusOr_EmojiRemover(StatusOr_EmojiRemover const & other) : StatusOr_EmojiRemover{inworld_StatusOr_EmojiRemover_copy(other.swig_self())} {}
inline StatusOr_SentenceStream::StatusOr_SentenceStream() : StatusOr_SentenceStream{inworld_StatusOr_SentenceStream_new()} {}
inline StatusOr_SentenceStream::StatusOr_SentenceStream(SentenceStream const& value) : StatusOr_SentenceStream{inworld_StatusOr_SentenceStream_new_rcstd_shared_ptr_Sl_inworld_SentenceStream_Sg_(value.swig_self())} {}
inline StatusOr_SentenceStream::StatusOr_SentenceStream(Status const & status) : StatusOr_SentenceStream{inworld_StatusOr_SentenceStream_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SentenceStream::ok() const { return inworld_StatusOr_SentenceStream_ok(swig_self()); }
inline Status StatusOr_SentenceStream::status() const {
  auto swig_cres = inworld_StatusOr_SentenceStream_status(swig_self());
  return Status{swig_cres, false};
}
inline SentenceStream StatusOr_SentenceStream::value() const {
  auto swig_cres = inworld_StatusOr_SentenceStream_value(swig_self());
  return SentenceStream{swig_cres, true};
}
inline StatusOr_SentenceStream::StatusOr_SentenceStream(StatusOr_SentenceStream const & other) : StatusOr_SentenceStream{inworld_StatusOr_SentenceStream_copy(other.swig_self())} {}
inline StatusOr_SubstringRemover::StatusOr_SubstringRemover() : StatusOr_SubstringRemover{inworld_StatusOr_SubstringRemover_new()} {}
inline StatusOr_SubstringRemover::StatusOr_SubstringRemover(SubstringRemover const& value) : StatusOr_SubstringRemover{inworld_StatusOr_SubstringRemover_new_rcstd_shared_ptr_Sl_inworld_SubstringRemover_Sg_(value.swig_self())} {}
inline StatusOr_SubstringRemover::StatusOr_SubstringRemover(Status const & status) : StatusOr_SubstringRemover{inworld_StatusOr_SubstringRemover_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SubstringRemover::ok() const { return inworld_StatusOr_SubstringRemover_ok(swig_self()); }
inline Status StatusOr_SubstringRemover::status() const {
  auto swig_cres = inworld_StatusOr_SubstringRemover_status(swig_self());
  return Status{swig_cres, false};
}
inline SubstringRemover StatusOr_SubstringRemover::value() const {
  auto swig_cres = inworld_StatusOr_SubstringRemover_value(swig_self());
  return SubstringRemover{swig_cres, true};
}
inline StatusOr_SubstringRemover::StatusOr_SubstringRemover(StatusOr_SubstringRemover const & other) : StatusOr_SubstringRemover{inworld_StatusOr_SubstringRemover_copy(other.swig_self())} {}
inline StatusOr_TextInBracketsRemover::StatusOr_TextInBracketsRemover() : StatusOr_TextInBracketsRemover{inworld_StatusOr_TextInBracketsRemover_new()} {}
inline StatusOr_TextInBracketsRemover::StatusOr_TextInBracketsRemover(TextInBracketsRemover const& value) : StatusOr_TextInBracketsRemover{inworld_StatusOr_TextInBracketsRemover_new_rcstd_shared_ptr_Sl_inworld_TextInBracketsRemover_Sg_(value.swig_self())} {}
inline StatusOr_TextInBracketsRemover::StatusOr_TextInBracketsRemover(Status const & status) : StatusOr_TextInBracketsRemover{inworld_StatusOr_TextInBracketsRemover_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_TextInBracketsRemover::ok() const { return inworld_StatusOr_TextInBracketsRemover_ok(swig_self()); }
inline Status StatusOr_TextInBracketsRemover::status() const {
  auto swig_cres = inworld_StatusOr_TextInBracketsRemover_status(swig_self());
  return Status{swig_cres, false};
}
inline TextInBracketsRemover StatusOr_TextInBracketsRemover::value() const {
  auto swig_cres = inworld_StatusOr_TextInBracketsRemover_value(swig_self());
  return TextInBracketsRemover{swig_cres, true};
}
inline StatusOr_TextInBracketsRemover::StatusOr_TextInBracketsRemover(StatusOr_TextInBracketsRemover const & other) : StatusOr_TextInBracketsRemover{inworld_StatusOr_TextInBracketsRemover_copy(other.swig_self())} {}
inline StatusOr_ContentToStringStream::StatusOr_ContentToStringStream() : StatusOr_ContentToStringStream{inworld_StatusOr_ContentToStringStream_new()} {}
inline StatusOr_ContentToStringStream::StatusOr_ContentToStringStream(ContentToStringStream const& value) : StatusOr_ContentToStringStream{inworld_StatusOr_ContentToStringStream_new_rcstd_shared_ptr_Sl_inworld_ContentToStringStream_Sg_(value.swig_self())} {}
inline StatusOr_ContentToStringStream::StatusOr_ContentToStringStream(Status const & status) : StatusOr_ContentToStringStream{inworld_StatusOr_ContentToStringStream_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_ContentToStringStream::ok() const { return inworld_StatusOr_ContentToStringStream_ok(swig_self()); }
inline Status StatusOr_ContentToStringStream::status() const {
  auto swig_cres = inworld_StatusOr_ContentToStringStream_status(swig_self());
  return Status{swig_cres, false};
}
inline ContentToStringStream StatusOr_ContentToStringStream::value() const {
  auto swig_cres = inworld_StatusOr_ContentToStringStream_value(swig_self());
  return ContentToStringStream{swig_cres, true};
}
inline StatusOr_ContentToStringStream::StatusOr_ContentToStringStream(StatusOr_ContentToStringStream const & other) : StatusOr_ContentToStringStream{inworld_StatusOr_ContentToStringStream_copy(other.swig_self())} {}
inline StatusOr_NERInterface::StatusOr_NERInterface() : StatusOr_NERInterface{inworld_StatusOr_NERInterface_new()} {}
inline StatusOr_NERInterface::StatusOr_NERInterface(NERInterface const& value) : StatusOr_NERInterface{inworld_StatusOr_NERInterface_new_rcstd_shared_ptr_Sl_inworld_NERInterface_Sg_(value.swig_self())} {}
inline StatusOr_NERInterface::StatusOr_NERInterface(Status const & status) : StatusOr_NERInterface{inworld_StatusOr_NERInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_NERInterface::ok() const { return inworld_StatusOr_NERInterface_ok(swig_self()); }
inline Status StatusOr_NERInterface::status() const {
  auto swig_cres = inworld_StatusOr_NERInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline NERInterface StatusOr_NERInterface::value() const {
  auto swig_cres = inworld_StatusOr_NERInterface_value(swig_self());
  return NERInterface{swig_cres, true};
}
inline StatusOr_NERInterface::StatusOr_NERInterface(StatusOr_NERInterface const & other) : StatusOr_NERInterface{inworld_StatusOr_NERInterface_copy(other.swig_self())} {}
inline StatusOr_CreationContext::StatusOr_CreationContext() : StatusOr_CreationContext{inworld_StatusOr_CreationContext_new()} {}
inline StatusOr_CreationContext::StatusOr_CreationContext(CreationContext const & value) : StatusOr_CreationContext{inworld_StatusOr_CreationContext_new_rcinworld_CreationContext(value.swig_self())} {}
inline StatusOr_CreationContext::StatusOr_CreationContext(Status const & status) : StatusOr_CreationContext{inworld_StatusOr_CreationContext_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_CreationContext::ok() const { return inworld_StatusOr_CreationContext_ok(swig_self()); }
inline Status StatusOr_CreationContext::status() const {
  auto swig_cres = inworld_StatusOr_CreationContext_status(swig_self());
  return Status{swig_cres, false};
}
inline CreationContext StatusOr_CreationContext::value() const {
  auto swig_cres = inworld_StatusOr_CreationContext_value(swig_self());
  return CreationContext{swig_cres, true};
}
inline StatusOr_CreationContext::StatusOr_CreationContext(StatusOr_CreationContext const & other) : StatusOr_CreationContext{inworld_StatusOr_CreationContext_copy(other.swig_self())} {}
inline StatusOr_MCPClientInterface::StatusOr_MCPClientInterface() : StatusOr_MCPClientInterface{inworld_StatusOr_MCPClientInterface_new()} {}
inline StatusOr_MCPClientInterface::StatusOr_MCPClientInterface(MCPClientInterface const& value) : StatusOr_MCPClientInterface{inworld_StatusOr_MCPClientInterface_new_rcstd_shared_ptr_Sl_inworld_MCPClientInterface_SS_const_Sg_(value.swig_self())} {}
inline StatusOr_MCPClientInterface::StatusOr_MCPClientInterface(Status const & status) : StatusOr_MCPClientInterface{inworld_StatusOr_MCPClientInterface_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_MCPClientInterface::ok() const { return inworld_StatusOr_MCPClientInterface_ok(swig_self()); }
inline Status StatusOr_MCPClientInterface::status() const {
  auto swig_cres = inworld_StatusOr_MCPClientInterface_status(swig_self());
  return Status{swig_cres, false};
}
inline MCPClientInterface StatusOr_MCPClientInterface::value() const {
  auto swig_cres = inworld_StatusOr_MCPClientInterface_value(swig_self());
  return MCPClientInterface{swig_cres, true};
}
inline StatusOr_MCPClientInterface::StatusOr_MCPClientInterface(StatusOr_MCPClientInterface const & other) : StatusOr_MCPClientInterface{inworld_StatusOr_MCPClientInterface_copy(other.swig_self())} {}
inline ComponentStore::ComponentStore() : ComponentStore{inworld_ComponentStore_new()} {}
inline void ComponentStore::Clear() { inworld_ComponentStore_Clear(swig_self()); }
inline Status ComponentStore::AddComponent_LLMInterface(std::string const& id, LLMInterface const& arg3) {
  auto swig_cres = inworld_ComponentStore_AddComponent_LLMInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status ComponentStore::AddComponent_STTInterface(std::string const& id, STTInterface const& arg3) {
  auto swig_cres = inworld_ComponentStore_AddComponent_STTInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status ComponentStore::AddComponent_StreamingSTTInterface(std::string const& id, StreamingSTTInterface const& arg3) {
  auto swig_cres = inworld_ComponentStore_AddComponent_StreamingSTTInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status ComponentStore::AddComponent_TTSInterface(std::string const& id, TTSInterface const& arg3) {
  auto swig_cres = inworld_ComponentStore_AddComponent_TTSInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status ComponentStore::AddComponent_TextEmbedderInterface(std::string const& id, TextEmbedderInterface const& arg3) {
  auto swig_cres = inworld_ComponentStore_AddComponent_TextEmbedderInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status ComponentStore::AddComponent_KnowledgeInterface(std::string const& id, KnowledgeInterface const& arg3) {
  auto swig_cres = inworld_ComponentStore_AddComponent_KnowledgeInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status ComponentStore::AddComponent_MCPClientInterface(std::string const& id, MCPClientInterface const& arg3) {
  auto swig_cres = inworld_ComponentStore_AddComponent_MCPClientInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline CreationContext::CreationContext(ComponentStore * component_store) : CreationContext{inworld_CreationContext_new_pinworld_ComponentStore(component_store->swig_self())} {}
inline StatusOr_LLMInterface CreationContext::GetComponent_LLMInterface(std::string const& id) {
  auto swig_cres = inworld_CreationContext_GetComponent_LLMInterface(swig_self(), (&id)->c_str());
  return StatusOr_LLMInterface{swig_cres, true};
}
inline StatusOr_STTInterface CreationContext::GetComponent_STTInterface(std::string const& id) {
  auto swig_cres = inworld_CreationContext_GetComponent_STTInterface(swig_self(), (&id)->c_str());
  return StatusOr_STTInterface{swig_cres, true};
}
inline StatusOr_StreamingSTTInterface CreationContext::GetComponent_StreamingSTTInterface(std::string const& id) {
  auto swig_cres = inworld_CreationContext_GetComponent_StreamingSTTInterface(swig_self(), (&id)->c_str());
  return StatusOr_StreamingSTTInterface{swig_cres, true};
}
inline StatusOr_TTSInterface CreationContext::GetComponent_TTSInterface(std::string const& id) {
  auto swig_cres = inworld_CreationContext_GetComponent_TTSInterface(swig_self(), (&id)->c_str());
  return StatusOr_TTSInterface{swig_cres, true};
}
inline StatusOr_TextEmbedderInterface CreationContext::GetComponent_TextEmbedderInterface(std::string const& id) {
  auto swig_cres = inworld_CreationContext_GetComponent_TextEmbedderInterface(swig_self(), (&id)->c_str());
  return StatusOr_TextEmbedderInterface{swig_cres, true};
}
inline StatusOr_KnowledgeInterface CreationContext::GetComponent_KnowledgeInterface(std::string const& id) {
  auto swig_cres = inworld_CreationContext_GetComponent_KnowledgeInterface(swig_self(), (&id)->c_str());
  return StatusOr_KnowledgeInterface{swig_cres, true};
}
inline StatusOr_MCPClientInterface CreationContext::GetComponent_MCPClientInterface(std::string const& id) {
  auto swig_cres = inworld_CreationContext_GetComponent_MCPClientInterface(swig_self(), (&id)->c_str());
  return StatusOr_MCPClientInterface{swig_cres, true};
}
inline CreationContext::CreationContext(CreationContext const & other) : CreationContext{inworld_CreationContext_copy(other.swig_self())} {}
inline ComponentRegistry ComponentRegistry::GetInstance() {
  auto swig_cres = inworld_ComponentRegistry_GetInstance();
  return ComponentRegistry{swig_cres, false};
}
inline bool ComponentRegistry::IsComponentRegistered(std::string const& type) { return inworld_ComponentRegistry_IsComponentRegistered(swig_self(), (&type)->c_str()); }
inline Status ComponentRegistry::UnregisterComponent(std::string const& type) {
  auto swig_cres = inworld_ComponentRegistry_UnregisterComponent(swig_self(), (&type)->c_str());
  return Status{swig_cres, true};
}
inline void ComponentRegistry::Clear() { inworld_ComponentRegistry_Clear(swig_self()); }
inline StatusOr_LLMInterface ComponentRegistry::CreateComponent_LLMInterface(std::string const& id, CreationContext const & arg3, LocalLLMConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_LLMInterface_rcstd_string_rcinworld_CreationContext_rcinworld_LocalLLMConfig(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_LLMInterface{swig_cres, true};
}
inline StatusOr_LLMInterface ComponentRegistry::CreateComponent_LLMInterface(std::string const& id, CreationContext const & arg3, RemoteLLMConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_LLMInterface_rcstd_string_rcinworld_CreationContext_rcinworld_RemoteLLMConfig(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_LLMInterface{swig_cres, true};
}
inline StatusOr_LLMInterface ComponentRegistry::CreateComponent_LLMRouting(std::string const& id, CreationContext const & arg3, LLMRoutingCreationConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_LLMRouting(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_LLMInterface{swig_cres, true};
}
inline StatusOr_STTInterface ComponentRegistry::CreateComponent_STTInterface(std::string const& id, CreationContext const & arg3, LocalSTTConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_STTInterface_rcstd_string_rcinworld_CreationContext_rcinworld_LocalSTTConfig(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_STTInterface{swig_cres, true};
}
inline StatusOr_STTInterface ComponentRegistry::CreateComponent_STTInterface(std::string const& id, CreationContext const & arg3, RemoteSTTConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_STTInterface_rcstd_string_rcinworld_CreationContext_rcinworld_RemoteSTTConfig(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_STTInterface{swig_cres, true};
}
inline StatusOr_StreamingSTTInterface ComponentRegistry::CreateComponent_StreamingSTTInterface(std::string const& id, CreationContext const & arg3, LocalStreamingSTTConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_StreamingSTTInterface_rcstd_string_rcinworld_CreationContext_rcinworld_LocalStreamingSTTConfig(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_StreamingSTTInterface{swig_cres, true};
}
inline StatusOr_StreamingSTTInterface ComponentRegistry::CreateComponent_StreamingSTTInterface(std::string const& id, CreationContext const & arg3, RemoteStreamingSTTConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_StreamingSTTInterface_rcstd_string_rcinworld_CreationContext_rcinworld_RemoteStreamingSTTConfig(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_StreamingSTTInterface{swig_cres, true};
}
inline StatusOr_TTSInterface ComponentRegistry::CreateComponent_TTSInterface(std::string const& id, CreationContext const & arg3, RemoteTTSConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_TTSInterface(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_TTSInterface{swig_cres, true};
}
inline StatusOr_TextEmbedderInterface ComponentRegistry::CreateComponent_TextEmbedderInterface(std::string const& id, CreationContext const & arg3, LocalTextEmbedderConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_TextEmbedderInterface_rcstd_string_rcinworld_CreationContext_rcinworld_LocalTextEmbedderConfig(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_TextEmbedderInterface{swig_cres, true};
}
inline StatusOr_TextEmbedderInterface ComponentRegistry::CreateComponent_TextEmbedderInterface(std::string const& id, CreationContext const & arg3, RemoteTextEmbedderConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_TextEmbedderInterface_rcstd_string_rcinworld_CreationContext_rcinworld_RemoteTextEmbedderConfig(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_TextEmbedderInterface{swig_cres, true};
}
inline StatusOr_KnowledgeInterface ComponentRegistry::CreateComponent_KnowledgeInterface(std::string const& id, CreationContext const & arg3, LocalKnowledgeConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_KnowledgeInterface_rcstd_string_rcinworld_CreationContext_rcinworld_LocalKnowledgeConfig(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_KnowledgeInterface{swig_cres, true};
}
inline StatusOr_KnowledgeInterface ComponentRegistry::CreateComponent_KnowledgeInterface(std::string const& id, CreationContext const & arg3, RemoteKnowledgeConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_KnowledgeInterface_rcstd_string_rcinworld_CreationContext_rcinworld_RemoteKnowledgeConfig(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_KnowledgeInterface{swig_cres, true};
}
inline StatusOr_MCPClientInterface ComponentRegistry::CreateComponent_MCPClientInterface(std::string const& id, CreationContext const & arg3, MCPClientCreationConfig const & arg4) {
  auto swig_cres = inworld_ComponentRegistry_CreateComponent_MCPClientInterface(swig_self(), (&id)->c_str(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_MCPClientInterface{swig_cres, true};
}
inline Status ComponentRegistry::RegisterCustomEdgeCondition(std::string const& name, EdgeConditionExecutor const & arg3) {
  auto swig_cres = inworld_ComponentRegistry_RegisterCustomEdgeCondition_rcstd_string_rcinworld_swig_helpers_EdgeConditionExecutor(swig_self(), (&name)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status ComponentRegistry::RegisterCustomEdgeCondition(std::string const& name, EdgeConditionThreadedExecutor const & arg3) {
  auto swig_cres = inworld_ComponentRegistry_RegisterCustomEdgeCondition_rcstd_string_rcinworld_swig_helpers_EdgeConditionThreadedExecutor(swig_self(), (&name)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status ComponentRegistry::RegisterCustomNode(std::string const& type, CustomNodeThreadedCreateExecutor const & arg3) {
  auto swig_cres = inworld_ComponentRegistry_RegisterCustomNode(swig_self(), (&type)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline vector_StatusCode::vector_StatusCode() : vector_StatusCode{inworld_vector_StatusCode_new()} {}
inline vector_StatusCode::vector_StatusCode(vector_StatusCode const & other) : vector_StatusCode{inworld_vector_StatusCode_copy(other.swig_self())} {}
inline size_t vector_StatusCode::size() const { return inworld_vector_StatusCode_size(swig_self()); }
inline size_t vector_StatusCode::capacity() const { return inworld_vector_StatusCode_capacity(swig_self()); }
inline void vector_StatusCode::reserve(size_t n) { inworld_vector_StatusCode_reserve(swig_self(), n); }
inline bool vector_StatusCode::empty() const { return inworld_vector_StatusCode_empty(swig_self()); }
inline void vector_StatusCode::clear() { inworld_vector_StatusCode_clear(swig_self()); }
inline void vector_StatusCode::push_back(StatusCode & x) { inworld_vector_StatusCode_push_back(swig_self(), (inworld_StatusCode*)&(x)); }
inline StatusCode vector_StatusCode::get(int i) {
  auto swig_cres = inworld_vector_StatusCode_get(swig_self(), i);
  return (StatusCode)(*(swig_cres));
}
inline void vector_StatusCode::set(int i, StatusCode & arg3) { inworld_vector_StatusCode_set(swig_self(), i, (inworld_StatusCode*)&(arg3)); }
inline void NodeExecutionConfig::report_to_client(bool report_to_client) { inworld_NodeExecutionConfig_report_to_client_set(swig_self(), report_to_client); }
inline bool NodeExecutionConfig::report_to_client() const { return inworld_NodeExecutionConfig_report_to_client_get(swig_self()); }
inline void NodeExecutionConfig::properties(map_string_string * properties) { inworld_NodeExecutionConfig_properties_set(swig_self(), properties->swig_self()); }
inline map_string_string * NodeExecutionConfig::properties() const {
  auto swig_cres = inworld_NodeExecutionConfig_properties_get(swig_self());
  return swig_cres ? new map_string_string(swig_cres, false) : nullptr;
}
inline bool NodeExecutionConfig::is_valid() const { return inworld_NodeExecutionConfig_is_valid(swig_self()); }
inline StatusOr_string NodeExecutionConfig::toJsonString() const {
  auto swig_cres = inworld_NodeExecutionConfig_toJsonString(swig_self());
  return StatusOr_string{swig_cres, true};
}
inline NodeExecutionConfig NodeExecutionConfig::inworld_inworld_graphs_NodeExecutionConfig_CreateWithReportFlag__SWIG(bool report_to_client) {
  auto swig_cres = inworld_NodeExecutionConfig_CreateWithReportFlag(report_to_client);
  return NodeExecutionConfig{swig_cres, true};
}
inline NodeExecutionConfig NodeExecutionConfig::inworld_inworld_graphs_NodeExecutionConfig_CreateWithProperties__SWIG(bool report_to_client, map_string_string const & arg2) {
  auto swig_cres = inworld_NodeExecutionConfig_CreateWithProperties(report_to_client, arg2.swig_self());
  return NodeExecutionConfig{swig_cres, true};
}
inline StatusOr_CustomConfigWrapper::StatusOr_CustomConfigWrapper() : StatusOr_CustomConfigWrapper{inworld_StatusOr_CustomConfigWrapper_new()} {}
inline StatusOr_CustomConfigWrapper::StatusOr_CustomConfigWrapper(CustomConfigWrapper const& value) : StatusOr_CustomConfigWrapper{inworld_StatusOr_CustomConfigWrapper_new_rcstd_shared_ptr_Sl_inworld_swig_helpers_CustomConfigWrapper_Sg_(value.swig_self())} {}
inline StatusOr_CustomConfigWrapper::StatusOr_CustomConfigWrapper(Status const & status) : StatusOr_CustomConfigWrapper{inworld_StatusOr_CustomConfigWrapper_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_CustomConfigWrapper::ok() const { return inworld_StatusOr_CustomConfigWrapper_ok(swig_self()); }
inline Status StatusOr_CustomConfigWrapper::status() const {
  auto swig_cres = inworld_StatusOr_CustomConfigWrapper_status(swig_self());
  return Status{swig_cres, false};
}
inline CustomConfigWrapper StatusOr_CustomConfigWrapper::value() const {
  auto swig_cres = inworld_StatusOr_CustomConfigWrapper_value(swig_self());
  return CustomConfigWrapper{swig_cres, true};
}
inline StatusOr_CustomConfigWrapper::StatusOr_CustomConfigWrapper(StatusOr_CustomConfigWrapper const & other) : StatusOr_CustomConfigWrapper{inworld_StatusOr_CustomConfigWrapper_copy(other.swig_self())} {}
inline StatusOr_CustomExecutionConfigWrapper::StatusOr_CustomExecutionConfigWrapper() : StatusOr_CustomExecutionConfigWrapper{inworld_StatusOr_CustomExecutionConfigWrapper_new()} {}
inline StatusOr_CustomExecutionConfigWrapper::StatusOr_CustomExecutionConfigWrapper(CustomExecutionConfigWrapper const& value) : StatusOr_CustomExecutionConfigWrapper{inworld_StatusOr_CustomExecutionConfigWrapper_new_rcstd_shared_ptr_Sl_inworld_swig_helpers_CustomExecutionConfigWrapper_Sg_(value.swig_self())} {}
inline StatusOr_CustomExecutionConfigWrapper::StatusOr_CustomExecutionConfigWrapper(Status const & status) : StatusOr_CustomExecutionConfigWrapper{inworld_StatusOr_CustomExecutionConfigWrapper_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_CustomExecutionConfigWrapper::ok() const { return inworld_StatusOr_CustomExecutionConfigWrapper_ok(swig_self()); }
inline Status StatusOr_CustomExecutionConfigWrapper::status() const {
  auto swig_cres = inworld_StatusOr_CustomExecutionConfigWrapper_status(swig_self());
  return Status{swig_cres, false};
}
inline CustomExecutionConfigWrapper StatusOr_CustomExecutionConfigWrapper::value() const {
  auto swig_cres = inworld_StatusOr_CustomExecutionConfigWrapper_value(swig_self());
  return CustomExecutionConfigWrapper{swig_cres, true};
}
inline StatusOr_CustomExecutionConfigWrapper::StatusOr_CustomExecutionConfigWrapper(StatusOr_CustomExecutionConfigWrapper const & other) : StatusOr_CustomExecutionConfigWrapper{inworld_StatusOr_CustomExecutionConfigWrapper_copy(other.swig_self())} {}
inline vector_CustomConfigWrapper::vector_CustomConfigWrapper() : vector_CustomConfigWrapper{inworld_vector_CustomConfigWrapper_new()} {}
inline vector_CustomConfigWrapper::vector_CustomConfigWrapper(vector_CustomConfigWrapper const & other) : vector_CustomConfigWrapper{inworld_vector_CustomConfigWrapper_copy(other.swig_self())} {}
inline size_t vector_CustomConfigWrapper::size() const { return inworld_vector_CustomConfigWrapper_size(swig_self()); }
inline size_t vector_CustomConfigWrapper::capacity() const { return inworld_vector_CustomConfigWrapper_capacity(swig_self()); }
inline void vector_CustomConfigWrapper::reserve(size_t n) { inworld_vector_CustomConfigWrapper_reserve(swig_self(), n); }
inline bool vector_CustomConfigWrapper::empty() const { return inworld_vector_CustomConfigWrapper_empty(swig_self()); }
inline void vector_CustomConfigWrapper::clear() { inworld_vector_CustomConfigWrapper_clear(swig_self()); }
inline void vector_CustomConfigWrapper::push_back(CustomConfigWrapper const& x) { inworld_vector_CustomConfigWrapper_push_back(swig_self(), x.swig_self()); }
inline CustomConfigWrapper vector_CustomConfigWrapper::get(int i) {
  auto swig_cres = inworld_vector_CustomConfigWrapper_get(swig_self(), i);
  return CustomConfigWrapper{swig_cres, true};
}
inline void vector_CustomConfigWrapper::set(int i, CustomConfigWrapper const& arg3) { inworld_vector_CustomConfigWrapper_set(swig_self(), i, arg3.swig_self()); }
inline CustomConfigWrapper vector_CustomConfigWrapper::safe_get(size_t index) const {
  auto swig_cres = inworld_vector_CustomConfigWrapper_safe_get(swig_self(), index);
  return CustomConfigWrapper{swig_cres, true};
}
inline vector_CustomExecutionConfigWrapper::vector_CustomExecutionConfigWrapper() : vector_CustomExecutionConfigWrapper{inworld_vector_CustomExecutionConfigWrapper_new()} {}
inline vector_CustomExecutionConfigWrapper::vector_CustomExecutionConfigWrapper(vector_CustomExecutionConfigWrapper const & other) : vector_CustomExecutionConfigWrapper{inworld_vector_CustomExecutionConfigWrapper_copy(other.swig_self())} {}
inline size_t vector_CustomExecutionConfigWrapper::size() const { return inworld_vector_CustomExecutionConfigWrapper_size(swig_self()); }
inline size_t vector_CustomExecutionConfigWrapper::capacity() const { return inworld_vector_CustomExecutionConfigWrapper_capacity(swig_self()); }
inline void vector_CustomExecutionConfigWrapper::reserve(size_t n) { inworld_vector_CustomExecutionConfigWrapper_reserve(swig_self(), n); }
inline bool vector_CustomExecutionConfigWrapper::empty() const { return inworld_vector_CustomExecutionConfigWrapper_empty(swig_self()); }
inline void vector_CustomExecutionConfigWrapper::clear() { inworld_vector_CustomExecutionConfigWrapper_clear(swig_self()); }
inline void vector_CustomExecutionConfigWrapper::push_back(CustomExecutionConfigWrapper const& x) { inworld_vector_CustomExecutionConfigWrapper_push_back(swig_self(), x.swig_self()); }
inline CustomExecutionConfigWrapper vector_CustomExecutionConfigWrapper::get(int i) {
  auto swig_cres = inworld_vector_CustomExecutionConfigWrapper_get(swig_self(), i);
  return CustomExecutionConfigWrapper{swig_cres, true};
}
inline void vector_CustomExecutionConfigWrapper::set(int i, CustomExecutionConfigWrapper const& arg3) { inworld_vector_CustomExecutionConfigWrapper_set(swig_self(), i, arg3.swig_self()); }
inline CustomExecutionConfigWrapper vector_CustomExecutionConfigWrapper::safe_get(size_t index) const {
  auto swig_cres = inworld_vector_CustomExecutionConfigWrapper_safe_get(swig_self(), index);
  return CustomExecutionConfigWrapper{swig_cres, true};
}
inline SerializerRegistry SerializerRegistry::GetInstance() {
  auto swig_cres = inworld_SerializerRegistry_GetInstance();
  return SerializerRegistry{swig_cres, false};
}
inline void SerializerRegistry::Clear() { inworld_SerializerRegistry_Clear(swig_self()); }
inline Status SerializerRegistry::RegisterCustomConfig(const char * type, CustomConfigThreadedDeserializeExecutor const & arg3, CustomConfigThreadedSerializeExecutor const & arg4) {
  auto swig_cres = inworld_SerializerRegistry_RegisterCustomConfig(swig_self(), type, arg3.swig_self(), arg4.swig_self());
  return Status{swig_cres, true};
}
inline Status SerializerRegistry::RegisterCustomExecutionConfig(const char * type, CustomExecutionConfigThreadedDeserializeExecutor const & arg3, CustomExecutionConfigThreadedSerializeExecutor const & arg4) {
  auto swig_cres = inworld_SerializerRegistry_RegisterCustomExecutionConfig(swig_self(), type, arg3.swig_self(), arg4.swig_self());
  return Status{swig_cres, true};
}
inline StatusOr_CustomConfigWrapper SerializerRegistry::DeserializeCustomConfig(const char * type, const char * arg3) {
  auto swig_cres = inworld_SerializerRegistry_DeserializeCustomConfig(swig_self(), type, arg3);
  return StatusOr_CustomConfigWrapper{swig_cres, true};
}
inline StatusOr_string SerializerRegistry::SerializeCustomConfig(const char * type, CustomConfigWrapper const& arg3) {
  auto swig_cres = inworld_SerializerRegistry_SerializeCustomConfig(swig_self(), type, arg3.swig_self());
  return StatusOr_string{swig_cres, true};
}
inline StatusOr_CustomExecutionConfigWrapper SerializerRegistry::DeserializeCustomExecutionConfig(const char * type, const char * arg3) {
  auto swig_cres = inworld_SerializerRegistry_DeserializeCustomExecutionConfig(swig_self(), type, arg3);
  return StatusOr_CustomExecutionConfigWrapper{swig_cres, true};
}
inline StatusOr_string SerializerRegistry::SerializeCustomExecutionConfig(const char * type, CustomExecutionConfigWrapper const& arg3) {
  auto swig_cres = inworld_SerializerRegistry_SerializeCustomExecutionConfig(swig_self(), type, arg3.swig_self());
  return StatusOr_string{swig_cres, true};
}
inline ConfigWrapperDestructor::ConfigWrapperDestructor(void * context, void * arg2) : ConfigWrapperDestructor{inworld_ConfigWrapperDestructor_new_pv_pv(context, arg2)} {}
inline ConfigWrapperDestructor::ConfigWrapperDestructor(ConfigWrapperDestructor const & other) : ConfigWrapperDestructor{inworld_ConfigWrapperDestructor_copy(other.swig_self())} {}
inline CustomConfigWrapper::CustomConfigWrapper(const char * type_id, void * arg2, ConfigWrapperDestructor const & arg3) : CustomConfigWrapper{inworld_CustomConfigWrapper_new(type_id, arg2, arg3.swig_self())} {}
inline const char * CustomConfigWrapper::type_id() const { return inworld_CustomConfigWrapper_type_id(swig_self()); }
inline void * CustomConfigWrapper::value() const { return inworld_CustomConfigWrapper_value(swig_self()); }
inline CustomExecutionConfigWrapper::CustomExecutionConfigWrapper(const char * type_id, void * arg2, bool arg3, ConfigWrapperDestructor const & arg4) : CustomExecutionConfigWrapper{inworld_CustomExecutionConfigWrapper_new(type_id, arg2, arg3, arg4.swig_self())} {}
inline const char * CustomExecutionConfigWrapper::type_id() const { return inworld_CustomExecutionConfigWrapper_type_id(swig_self()); }
inline void * CustomExecutionConfigWrapper::value() const { return inworld_CustomExecutionConfigWrapper_value(swig_self()); }
inline CustomConfigThreadedSerializeExecutor::CustomConfigThreadedSerializeExecutor(void * context, void * arg2) : CustomConfigThreadedSerializeExecutor{inworld_CustomConfigThreadedSerializeExecutor_new_pv_pv(context, arg2)} {}
inline CustomConfigWrapper CustomConfigThreadedSerializeExecutor::GetInput(int execution_id) {
  auto swig_cres = inworld_CustomConfigThreadedSerializeExecutor_GetInput(execution_id);
  return CustomConfigWrapper{swig_cres, true};
}
inline void CustomConfigThreadedSerializeExecutor::SetOutput(int execution_id, const char * arg2) { inworld_CustomConfigThreadedSerializeExecutor_SetOutput(execution_id, arg2); }
inline CustomConfigThreadedSerializeExecutor::CustomConfigThreadedSerializeExecutor(CustomConfigThreadedSerializeExecutor const & other) : CustomConfigThreadedSerializeExecutor{inworld_CustomConfigThreadedSerializeExecutor_copy(other.swig_self())} {}
inline CustomConfigThreadedDeserializeExecutor::CustomConfigThreadedDeserializeExecutor(void * context, void * arg2) : CustomConfigThreadedDeserializeExecutor{inworld_CustomConfigThreadedDeserializeExecutor_new_pv_pv(context, arg2)} {}
inline std::string CustomConfigThreadedDeserializeExecutor::GetInput(int execution_id) {
  auto swig_cres = inworld_CustomConfigThreadedDeserializeExecutor_GetInput(execution_id);
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void CustomConfigThreadedDeserializeExecutor::SetOutput(int execution_id, StatusOr_CustomConfigWrapper const & arg2) { inworld_CustomConfigThreadedDeserializeExecutor_SetOutput(execution_id, arg2.swig_self()); }
inline CustomConfigThreadedDeserializeExecutor::CustomConfigThreadedDeserializeExecutor(CustomConfigThreadedDeserializeExecutor const & other) : CustomConfigThreadedDeserializeExecutor{inworld_CustomConfigThreadedDeserializeExecutor_copy(other.swig_self())} {}
inline CustomExecutionConfigThreadedSerializeExecutor::CustomExecutionConfigThreadedSerializeExecutor(void * context, void * arg2) : CustomExecutionConfigThreadedSerializeExecutor{inworld_CustomExecutionConfigThreadedSerializeExecutor_new_pv_pv(context, arg2)} {}
inline CustomExecutionConfigWrapper CustomExecutionConfigThreadedSerializeExecutor::GetInput(int execution_id) {
  auto swig_cres = inworld_CustomExecutionConfigThreadedSerializeExecutor_GetInput(execution_id);
  return CustomExecutionConfigWrapper{swig_cres, true};
}
inline void CustomExecutionConfigThreadedSerializeExecutor::SetOutput(int execution_id, const char * arg2) { inworld_CustomExecutionConfigThreadedSerializeExecutor_SetOutput(execution_id, arg2); }
inline CustomExecutionConfigThreadedSerializeExecutor::CustomExecutionConfigThreadedSerializeExecutor(CustomExecutionConfigThreadedSerializeExecutor const & other) : CustomExecutionConfigThreadedSerializeExecutor{inworld_CustomExecutionConfigThreadedSerializeExecutor_copy(other.swig_self())} {}
inline CustomExecutionConfigThreadedDeserializeExecutor::CustomExecutionConfigThreadedDeserializeExecutor(void * context, void * arg2) : CustomExecutionConfigThreadedDeserializeExecutor{inworld_CustomExecutionConfigThreadedDeserializeExecutor_new_pv_pv(context, arg2)} {}
inline std::string CustomExecutionConfigThreadedDeserializeExecutor::GetInput(int execution_id) {
  auto swig_cres = inworld_CustomExecutionConfigThreadedDeserializeExecutor_GetInput(execution_id);
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void CustomExecutionConfigThreadedDeserializeExecutor::SetOutput(int execution_id, StatusOr_CustomExecutionConfigWrapper const & arg2) { inworld_CustomExecutionConfigThreadedDeserializeExecutor_SetOutput(execution_id, arg2.swig_self()); }
inline CustomExecutionConfigThreadedDeserializeExecutor::CustomExecutionConfigThreadedDeserializeExecutor(CustomExecutionConfigThreadedDeserializeExecutor const & other) : CustomExecutionConfigThreadedDeserializeExecutor{inworld_CustomExecutionConfigThreadedDeserializeExecutor_copy(other.swig_self())} {}
inline bool InputStream_TTSOutput::HasNext() { return inworld_InputStream_TTSOutput_HasNext(swig_self()); }
inline StatusOr_TTSOutput InputStream_TTSOutput::Read() {
  auto swig_cres = inworld_InputStream_TTSOutput_Read(swig_self());
  return StatusOr_TTSOutput{swig_cres, true};
}
inline void InputStream_TTSOutput::Cancel() { inworld_InputStream_TTSOutput_Cancel(swig_self()); }
inline bool InputStream_TTSOutput::is_valid() const { return inworld_InputStream_TTSOutput_is_valid(swig_self()); }
inline bool InputStream_Content::HasNext() { return inworld_InputStream_Content_HasNext(swig_self()); }
inline StatusOr_Content InputStream_Content::Read() {
  auto swig_cres = inworld_InputStream_Content_Read(swig_self());
  return StatusOr_Content{swig_cres, true};
}
inline void InputStream_Content::Cancel() { inworld_InputStream_Content_Cancel(swig_self()); }
inline bool InputStream_Content::is_valid() const { return inworld_InputStream_Content_is_valid(swig_self()); }
inline bool InputStream_string::HasNext() { return inworld_InputStream_string_HasNext(swig_self()); }
inline StatusOr_string InputStream_string::Read() {
  auto swig_cres = inworld_InputStream_string_Read(swig_self());
  return StatusOr_string{swig_cres, true};
}
inline void InputStream_string::Cancel() { inworld_InputStream_string_Cancel(swig_self()); }
inline bool InputStream_string::is_valid() const { return inworld_InputStream_string_is_valid(swig_self()); }
inline bool InputStream_AudioChunk::HasNext() { return inworld_InputStream_AudioChunk_HasNext(swig_self()); }
inline StatusOr_AudioChunk InputStream_AudioChunk::Read() {
  auto swig_cres = inworld_InputStream_AudioChunk_Read(swig_self());
  return StatusOr_AudioChunk{swig_cres, true};
}
inline void InputStream_AudioChunk::Cancel() { inworld_InputStream_AudioChunk_Cancel(swig_self()); }
inline bool InputStream_AudioChunk::is_valid() const { return inworld_InputStream_AudioChunk_is_valid(swig_self()); }
inline bool InputStream_BaseData::HasNext() { return inworld_InputStream_BaseData_HasNext(swig_self()); }
inline StatusOr_BaseData InputStream_BaseData::Read() {
  auto swig_cres = inworld_InputStream_BaseData_Read(swig_self());
  return StatusOr_BaseData{swig_cres, true};
}
inline void InputStream_BaseData::Cancel() { inworld_InputStream_BaseData_Cancel(swig_self()); }
inline bool InputStream_BaseData::is_valid() const { return inworld_InputStream_BaseData_is_valid(swig_self()); }
inline StatusOr_InputStream_string::StatusOr_InputStream_string() : StatusOr_InputStream_string{inworld_StatusOr_InputStream_string_new()} {}
inline StatusOr_InputStream_string::StatusOr_InputStream_string(InputStream_string const& value) : StatusOr_InputStream_string{inworld_StatusOr_InputStream_string_new_rcstd_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg_(value.swig_self())} {}
inline StatusOr_InputStream_string::StatusOr_InputStream_string(Status const & status) : StatusOr_InputStream_string{inworld_StatusOr_InputStream_string_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_InputStream_string::ok() const { return inworld_StatusOr_InputStream_string_ok(swig_self()); }
inline Status StatusOr_InputStream_string::status() const {
  auto swig_cres = inworld_StatusOr_InputStream_string_status(swig_self());
  return Status{swig_cres, false};
}
inline InputStream_string StatusOr_InputStream_string::value() const {
  auto swig_cres = inworld_StatusOr_InputStream_string_value(swig_self());
  return InputStream_string{swig_cres, true};
}
inline StatusOr_InputStream_string::StatusOr_InputStream_string(StatusOr_InputStream_string const & other) : StatusOr_InputStream_string{inworld_StatusOr_InputStream_string_copy(other.swig_self())} {}
inline StatusOr_InputStream_AudioChunk::StatusOr_InputStream_AudioChunk() : StatusOr_InputStream_AudioChunk{inworld_StatusOr_InputStream_AudioChunk_new()} {}
inline StatusOr_InputStream_AudioChunk::StatusOr_InputStream_AudioChunk(InputStream_AudioChunk const& value) : StatusOr_InputStream_AudioChunk{inworld_StatusOr_InputStream_AudioChunk_new_rcstd_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg_(value.swig_self())} {}
inline StatusOr_InputStream_AudioChunk::StatusOr_InputStream_AudioChunk(Status const & status) : StatusOr_InputStream_AudioChunk{inworld_StatusOr_InputStream_AudioChunk_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_InputStream_AudioChunk::ok() const { return inworld_StatusOr_InputStream_AudioChunk_ok(swig_self()); }
inline Status StatusOr_InputStream_AudioChunk::status() const {
  auto swig_cres = inworld_StatusOr_InputStream_AudioChunk_status(swig_self());
  return Status{swig_cres, false};
}
inline InputStream_AudioChunk StatusOr_InputStream_AudioChunk::value() const {
  auto swig_cres = inworld_StatusOr_InputStream_AudioChunk_value(swig_self());
  return InputStream_AudioChunk{swig_cres, true};
}
inline StatusOr_InputStream_AudioChunk::StatusOr_InputStream_AudioChunk(StatusOr_InputStream_AudioChunk const & other) : StatusOr_InputStream_AudioChunk{inworld_StatusOr_InputStream_AudioChunk_copy(other.swig_self())} {}
inline StatusOr_InputStream_Content::StatusOr_InputStream_Content() : StatusOr_InputStream_Content{inworld_StatusOr_InputStream_Content_new()} {}
inline StatusOr_InputStream_Content::StatusOr_InputStream_Content(InputStream_Content const& value) : StatusOr_InputStream_Content{inworld_StatusOr_InputStream_Content_new_rcstd_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg_(value.swig_self())} {}
inline StatusOr_InputStream_Content::StatusOr_InputStream_Content(Status const & status) : StatusOr_InputStream_Content{inworld_StatusOr_InputStream_Content_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_InputStream_Content::ok() const { return inworld_StatusOr_InputStream_Content_ok(swig_self()); }
inline Status StatusOr_InputStream_Content::status() const {
  auto swig_cres = inworld_StatusOr_InputStream_Content_status(swig_self());
  return Status{swig_cres, false};
}
inline InputStream_Content StatusOr_InputStream_Content::value() const {
  auto swig_cres = inworld_StatusOr_InputStream_Content_value(swig_self());
  return InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content::StatusOr_InputStream_Content(StatusOr_InputStream_Content const & other) : StatusOr_InputStream_Content{inworld_StatusOr_InputStream_Content_copy(other.swig_self())} {}
inline StatusOr_InputStream_BaseData::StatusOr_InputStream_BaseData() : StatusOr_InputStream_BaseData{inworld_StatusOr_InputStream_BaseData_new()} {}
inline StatusOr_InputStream_BaseData::StatusOr_InputStream_BaseData(InputStream_BaseData const& value) : StatusOr_InputStream_BaseData{inworld_StatusOr_InputStream_BaseData_new_rcstd_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg_(value.swig_self())} {}
inline StatusOr_InputStream_BaseData::StatusOr_InputStream_BaseData(Status const & status) : StatusOr_InputStream_BaseData{inworld_StatusOr_InputStream_BaseData_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_InputStream_BaseData::ok() const { return inworld_StatusOr_InputStream_BaseData_ok(swig_self()); }
inline Status StatusOr_InputStream_BaseData::status() const {
  auto swig_cres = inworld_StatusOr_InputStream_BaseData_status(swig_self());
  return Status{swig_cres, false};
}
inline InputStream_BaseData StatusOr_InputStream_BaseData::value() const {
  auto swig_cres = inworld_StatusOr_InputStream_BaseData_value(swig_self());
  return InputStream_BaseData{swig_cres, true};
}
inline StatusOr_InputStream_BaseData::StatusOr_InputStream_BaseData(StatusOr_InputStream_BaseData const & other) : StatusOr_InputStream_BaseData{inworld_StatusOr_InputStream_BaseData_copy(other.swig_self())} {}
inline StatusOr_InputStream_TTSOutput::StatusOr_InputStream_TTSOutput() : StatusOr_InputStream_TTSOutput{inworld_StatusOr_InputStream_TTSOutput_new()} {}
inline StatusOr_InputStream_TTSOutput::StatusOr_InputStream_TTSOutput(InputStream_TTSOutput const& value) : StatusOr_InputStream_TTSOutput{inworld_StatusOr_InputStream_TTSOutput_new_rcstd_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg_(value.swig_self())} {}
inline StatusOr_InputStream_TTSOutput::StatusOr_InputStream_TTSOutput(Status const & status) : StatusOr_InputStream_TTSOutput{inworld_StatusOr_InputStream_TTSOutput_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_InputStream_TTSOutput::ok() const { return inworld_StatusOr_InputStream_TTSOutput_ok(swig_self()); }
inline Status StatusOr_InputStream_TTSOutput::status() const {
  auto swig_cres = inworld_StatusOr_InputStream_TTSOutput_status(swig_self());
  return Status{swig_cres, false};
}
inline InputStream_TTSOutput StatusOr_InputStream_TTSOutput::value() const {
  auto swig_cres = inworld_StatusOr_InputStream_TTSOutput_value(swig_self());
  return InputStream_TTSOutput{swig_cres, true};
}
inline StatusOr_InputStream_TTSOutput::StatusOr_InputStream_TTSOutput(StatusOr_InputStream_TTSOutput const & other) : StatusOr_InputStream_TTSOutput{inworld_StatusOr_InputStream_TTSOutput_copy(other.swig_self())} {}
inline BlockingStream_TTSOutput BlockingStream_TTSOutput::Create() {
  auto swig_cres = inworld_BlockingStream_TTSOutput_Create();
  return BlockingStream_TTSOutput{swig_cres, true};
}
inline bool BlockingStream_TTSOutput::Write(TTSOutput const& value) { return inworld_BlockingStream_TTSOutput_Write(swig_self(), value.swig_self()); }
inline void BlockingStream_TTSOutput::Close() { inworld_BlockingStream_TTSOutput_Close(swig_self()); }
inline void BlockingStream_TTSOutput::Close(Status const & status) { inworld_BlockingStream_TTSOutput_Close_rcabsl_Status(swig_self(), status.swig_self()); }
inline bool BlockingStream_TTSOutput::is_valid() const { return inworld_BlockingStream_TTSOutput_is_valid(swig_self()); }
inline BlockingStream_Content BlockingStream_Content::Create() {
  auto swig_cres = inworld_BlockingStream_Content_Create();
  return BlockingStream_Content{swig_cres, true};
}
inline bool BlockingStream_Content::Write(Content const& value) { return inworld_BlockingStream_Content_Write(swig_self(), value.swig_self()); }
inline void BlockingStream_Content::Close() { inworld_BlockingStream_Content_Close(swig_self()); }
inline void BlockingStream_Content::Close(Status const & status) { inworld_BlockingStream_Content_Close_rcabsl_Status(swig_self(), status.swig_self()); }
inline bool BlockingStream_Content::is_valid() const { return inworld_BlockingStream_Content_is_valid(swig_self()); }
inline BlockingStream_AudioChunk BlockingStream_AudioChunk::Create() {
  auto swig_cres = inworld_BlockingStream_AudioChunk_Create();
  return BlockingStream_AudioChunk{swig_cres, true};
}
inline bool BlockingStream_AudioChunk::Write(AudioChunk const& value) { return inworld_BlockingStream_AudioChunk_Write(swig_self(), value.swig_self()); }
inline void BlockingStream_AudioChunk::Close() { inworld_BlockingStream_AudioChunk_Close(swig_self()); }
inline void BlockingStream_AudioChunk::Close(Status const & status) { inworld_BlockingStream_AudioChunk_Close_rcabsl_Status(swig_self(), status.swig_self()); }
inline bool BlockingStream_AudioChunk::is_valid() const { return inworld_BlockingStream_AudioChunk_is_valid(swig_self()); }
inline BlockingStream_string BlockingStream_string::Create() {
  auto swig_cres = inworld_BlockingStream_string_Create();
  return BlockingStream_string{swig_cres, true};
}
inline bool BlockingStream_string::Write(std::string const& value) { return inworld_BlockingStream_string_Write(swig_self(), (&value)->c_str()); }
inline void BlockingStream_string::Close() { inworld_BlockingStream_string_Close(swig_self()); }
inline void BlockingStream_string::Close(Status const & status) { inworld_BlockingStream_string_Close_rcabsl_Status(swig_self(), status.swig_self()); }
inline bool BlockingStream_string::is_valid() const { return inworld_BlockingStream_string_is_valid(swig_self()); }
inline BlockingStream_BaseData BlockingStream_BaseData::Create() {
  auto swig_cres = inworld_BlockingStream_BaseData_Create();
  return BlockingStream_BaseData{swig_cres, true};
}
inline bool BlockingStream_BaseData::Write(BaseData const& value) { return inworld_BlockingStream_BaseData_Write(swig_self(), value.swig_self()); }
inline void BlockingStream_BaseData::Close() { inworld_BlockingStream_BaseData_Close(swig_self()); }
inline void BlockingStream_BaseData::Close(Status const & status) { inworld_BlockingStream_BaseData_Close_rcabsl_Status(swig_self(), status.swig_self()); }
inline bool BlockingStream_BaseData::is_valid() const { return inworld_BlockingStream_BaseData_is_valid(swig_self()); }
inline StatusOr_CustomStringStreamReadThruWrapper::StatusOr_CustomStringStreamReadThruWrapper() : StatusOr_CustomStringStreamReadThruWrapper{inworld_StatusOr_CustomStringStreamReadThruWrapper_new()} {}
inline StatusOr_CustomStringStreamReadThruWrapper::StatusOr_CustomStringStreamReadThruWrapper(CustomStringStreamReadThruWrapper const& value) : StatusOr_CustomStringStreamReadThruWrapper{inworld_StatusOr_CustomStringStreamReadThruWrapper_new_rcstd_shared_ptr_Sl_inworld_swig_helpers_CustomStringStreamReadThruWrapper_Sg_(value.swig_self())} {}
inline StatusOr_CustomStringStreamReadThruWrapper::StatusOr_CustomStringStreamReadThruWrapper(Status const & status) : StatusOr_CustomStringStreamReadThruWrapper{inworld_StatusOr_CustomStringStreamReadThruWrapper_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_CustomStringStreamReadThruWrapper::ok() const { return inworld_StatusOr_CustomStringStreamReadThruWrapper_ok(swig_self()); }
inline Status StatusOr_CustomStringStreamReadThruWrapper::status() const {
  auto swig_cres = inworld_StatusOr_CustomStringStreamReadThruWrapper_status(swig_self());
  return Status{swig_cres, false};
}
inline CustomStringStreamReadThruWrapper StatusOr_CustomStringStreamReadThruWrapper::value() const {
  auto swig_cres = inworld_StatusOr_CustomStringStreamReadThruWrapper_value(swig_self());
  return CustomStringStreamReadThruWrapper{swig_cres, true};
}
inline StatusOr_CustomStringStreamReadThruWrapper::StatusOr_CustomStringStreamReadThruWrapper(StatusOr_CustomStringStreamReadThruWrapper const & other) : StatusOr_CustomStringStreamReadThruWrapper{inworld_StatusOr_CustomStringStreamReadThruWrapper_copy(other.swig_self())} {}
inline CustomStringStreamReadThruExecutor::CustomStringStreamReadThruExecutor(void * source_object, void * arg2) : CustomStringStreamReadThruExecutor{inworld_CustomStringStreamReadThruExecutor_new_pv_pv(source_object, arg2)} {}
inline CustomStringStreamReadThruExecutor::CustomStringStreamReadThruExecutor(CustomStringStreamReadThruExecutor const & other) : CustomStringStreamReadThruExecutor{inworld_CustomStringStreamReadThruExecutor_copy(other.swig_self())} {}
inline StatusOr_CustomStringStreamReadThruWrapper CustomStringStreamReadThruWrapper::Create(InputStream_string const& input_stream, CustomStringStreamReadThruExecutor const & arg2) {
  auto swig_cres = inworld_CustomStringStreamReadThruWrapper_Create(input_stream.swig_self(), arg2.swig_self());
  return StatusOr_CustomStringStreamReadThruWrapper{swig_cres, true};
}
inline bool CustomStringStreamReadThruWrapper::is_valid() const { return inworld_CustomStringStreamReadThruWrapper_is_valid(swig_self()); }
inline CustomStringStreamReadThruWrapper::CustomStringStreamReadThruWrapper(CustomStringStreamReadThruWrapper const & other) : CustomStringStreamReadThruWrapper{inworld_CustomStringStreamReadThruWrapper_copy(other.swig_self())} {}
inline StatusOr_ContentToStringStream ContentToStringStream::Create(InputStream_Content const& content_stream) {
  auto swig_cres = inworld_ContentToStringStream_Create(content_stream.swig_self());
  return StatusOr_ContentToStringStream{swig_cres, true};
}
inline bool ContentToStringStream::is_valid() const { return inworld_ContentToStringStream_is_valid(swig_self()); }
inline vector_CompiledIntent::vector_CompiledIntent() : vector_CompiledIntent{inworld_vector_CompiledIntent_new()} {}
inline vector_CompiledIntent::vector_CompiledIntent(vector_CompiledIntent const & other) : vector_CompiledIntent{inworld_vector_CompiledIntent_copy(other.swig_self())} {}
inline size_t vector_CompiledIntent::size() const { return inworld_vector_CompiledIntent_size(swig_self()); }
inline size_t vector_CompiledIntent::capacity() const { return inworld_vector_CompiledIntent_capacity(swig_self()); }
inline void vector_CompiledIntent::reserve(size_t n) { inworld_vector_CompiledIntent_reserve(swig_self(), n); }
inline bool vector_CompiledIntent::empty() const { return inworld_vector_CompiledIntent_empty(swig_self()); }
inline void vector_CompiledIntent::clear() { inworld_vector_CompiledIntent_clear(swig_self()); }
inline void vector_CompiledIntent::push_back(CompiledIntent const & x) { inworld_vector_CompiledIntent_push_back(swig_self(), x.swig_self()); }
inline CompiledIntent vector_CompiledIntent::get(int i) {
  auto swig_cres = inworld_vector_CompiledIntent_get(swig_self(), i);
  return CompiledIntent{swig_cres, false};
}
inline void vector_CompiledIntent::set(int i, CompiledIntent const & arg3) { inworld_vector_CompiledIntent_set(swig_self(), i, arg3.swig_self()); }
inline vector_Device::vector_Device() : vector_Device{inworld_vector_Device_new()} {}
inline vector_Device::vector_Device(vector_Device const & other) : vector_Device{inworld_vector_Device_copy(other.swig_self())} {}
inline size_t vector_Device::size() const { return inworld_vector_Device_size(swig_self()); }
inline size_t vector_Device::capacity() const { return inworld_vector_Device_capacity(swig_self()); }
inline void vector_Device::reserve(size_t n) { inworld_vector_Device_reserve(swig_self(), n); }
inline bool vector_Device::empty() const { return inworld_vector_Device_empty(swig_self()); }
inline void vector_Device::clear() { inworld_vector_Device_clear(swig_self()); }
inline void vector_Device::push_back(Device const & x) { inworld_vector_Device_push_back(swig_self(), x.swig_self()); }
inline Device vector_Device::get(int i) {
  auto swig_cres = inworld_vector_Device_get(swig_self(), i);
  return Device{swig_cres, false};
}
inline void vector_Device::set(int i, Device const & arg3) { inworld_vector_Device_set(swig_self(), i, arg3.swig_self()); }
inline vector_Event::vector_Event() : vector_Event{inworld_vector_Event_new()} {}
inline vector_Event::vector_Event(vector_Event const & other) : vector_Event{inworld_vector_Event_copy(other.swig_self())} {}
inline size_t vector_Event::size() const { return inworld_vector_Event_size(swig_self()); }
inline size_t vector_Event::capacity() const { return inworld_vector_Event_capacity(swig_self()); }
inline void vector_Event::reserve(size_t n) { inworld_vector_Event_reserve(swig_self(), n); }
inline bool vector_Event::empty() const { return inworld_vector_Event_empty(swig_self()); }
inline void vector_Event::clear() { inworld_vector_Event_clear(swig_self()); }
inline void vector_Event::push_back(Event const & x) { inworld_vector_Event_push_back(swig_self(), x.swig_self()); }
inline Event vector_Event::get(int i) {
  auto swig_cres = inworld_vector_Event_get(swig_self(), i);
  return Event{swig_cres, false};
}
inline void vector_Event::set(int i, Event const & arg3) { inworld_vector_Event_set(swig_self(), i, arg3.swig_self()); }
inline vector_Intent::vector_Intent() : vector_Intent{inworld_vector_Intent_new()} {}
inline vector_Intent::vector_Intent(vector_Intent const & other) : vector_Intent{inworld_vector_Intent_copy(other.swig_self())} {}
inline size_t vector_Intent::size() const { return inworld_vector_Intent_size(swig_self()); }
inline size_t vector_Intent::capacity() const { return inworld_vector_Intent_capacity(swig_self()); }
inline void vector_Intent::reserve(size_t n) { inworld_vector_Intent_reserve(swig_self(), n); }
inline bool vector_Intent::empty() const { return inworld_vector_Intent_empty(swig_self()); }
inline void vector_Intent::clear() { inworld_vector_Intent_clear(swig_self()); }
inline void vector_Intent::push_back(Intent const & x) { inworld_vector_Intent_push_back(swig_self(), x.swig_self()); }
inline Intent vector_Intent::get(int i) {
  auto swig_cres = inworld_vector_Intent_get(swig_self(), i);
  return Intent{swig_cres, false};
}
inline void vector_Intent::set(int i, Intent const & arg3) { inworld_vector_Intent_set(swig_self(), i, arg3.swig_self()); }
inline vector_IntentMatch::vector_IntentMatch() : vector_IntentMatch{inworld_vector_IntentMatch_new()} {}
inline vector_IntentMatch::vector_IntentMatch(vector_IntentMatch const & other) : vector_IntentMatch{inworld_vector_IntentMatch_copy(other.swig_self())} {}
inline size_t vector_IntentMatch::size() const { return inworld_vector_IntentMatch_size(swig_self()); }
inline size_t vector_IntentMatch::capacity() const { return inworld_vector_IntentMatch_capacity(swig_self()); }
inline void vector_IntentMatch::reserve(size_t n) { inworld_vector_IntentMatch_reserve(swig_self(), n); }
inline bool vector_IntentMatch::empty() const { return inworld_vector_IntentMatch_empty(swig_self()); }
inline void vector_IntentMatch::clear() { inworld_vector_IntentMatch_clear(swig_self()); }
inline void vector_IntentMatch::push_back(IntentMatch const & x) { inworld_vector_IntentMatch_push_back(swig_self(), x.swig_self()); }
inline IntentMatch vector_IntentMatch::get(int i) {
  auto swig_cres = inworld_vector_IntentMatch_get(swig_self(), i);
  return IntentMatch{swig_cres, false};
}
inline void vector_IntentMatch::set(int i, IntentMatch const & arg3) { inworld_vector_IntentMatch_set(swig_self(), i, arg3.swig_self()); }
inline vector_KeywordMatch::vector_KeywordMatch() : vector_KeywordMatch{inworld_vector_KeywordMatch_new()} {}
inline vector_KeywordMatch::vector_KeywordMatch(vector_KeywordMatch const & other) : vector_KeywordMatch{inworld_vector_KeywordMatch_copy(other.swig_self())} {}
inline size_t vector_KeywordMatch::size() const { return inworld_vector_KeywordMatch_size(swig_self()); }
inline size_t vector_KeywordMatch::capacity() const { return inworld_vector_KeywordMatch_capacity(swig_self()); }
inline void vector_KeywordMatch::reserve(size_t n) { inworld_vector_KeywordMatch_reserve(swig_self(), n); }
inline bool vector_KeywordMatch::empty() const { return inworld_vector_KeywordMatch_empty(swig_self()); }
inline void vector_KeywordMatch::clear() { inworld_vector_KeywordMatch_clear(swig_self()); }
inline void vector_KeywordMatch::push_back(KeywordMatch const & x) { inworld_vector_KeywordMatch_push_back(swig_self(), x.swig_self()); }
inline KeywordMatch vector_KeywordMatch::get(int i) {
  auto swig_cres = inworld_vector_KeywordMatch_get(swig_self(), i);
  return KeywordMatch{swig_cres, false};
}
inline void vector_KeywordMatch::set(int i, KeywordMatch const & arg3) { inworld_vector_KeywordMatch_set(swig_self(), i, arg3.swig_self()); }
inline vector_KeywordGroup::vector_KeywordGroup() : vector_KeywordGroup{inworld_vector_KeywordGroup_new()} {}
inline vector_KeywordGroup::vector_KeywordGroup(vector_KeywordGroup const & other) : vector_KeywordGroup{inworld_vector_KeywordGroup_copy(other.swig_self())} {}
inline size_t vector_KeywordGroup::size() const { return inworld_vector_KeywordGroup_size(swig_self()); }
inline size_t vector_KeywordGroup::capacity() const { return inworld_vector_KeywordGroup_capacity(swig_self()); }
inline void vector_KeywordGroup::reserve(size_t n) { inworld_vector_KeywordGroup_reserve(swig_self(), n); }
inline bool vector_KeywordGroup::empty() const { return inworld_vector_KeywordGroup_empty(swig_self()); }
inline void vector_KeywordGroup::clear() { inworld_vector_KeywordGroup_clear(swig_self()); }
inline void vector_KeywordGroup::push_back(KeywordGroup const & x) { inworld_vector_KeywordGroup_push_back(swig_self(), x.swig_self()); }
inline KeywordGroup vector_KeywordGroup::get(int i) {
  auto swig_cres = inworld_vector_KeywordGroup_get(swig_self(), i);
  return KeywordGroup{swig_cres, false};
}
inline void vector_KeywordGroup::set(int i, KeywordGroup const & arg3) { inworld_vector_KeywordGroup_set(swig_self(), i, arg3.swig_self()); }
inline vector_PhraseMatch::vector_PhraseMatch() : vector_PhraseMatch{inworld_vector_PhraseMatch_new()} {}
inline vector_PhraseMatch::vector_PhraseMatch(vector_PhraseMatch const & other) : vector_PhraseMatch{inworld_vector_PhraseMatch_copy(other.swig_self())} {}
inline size_t vector_PhraseMatch::size() const { return inworld_vector_PhraseMatch_size(swig_self()); }
inline size_t vector_PhraseMatch::capacity() const { return inworld_vector_PhraseMatch_capacity(swig_self()); }
inline void vector_PhraseMatch::reserve(size_t n) { inworld_vector_PhraseMatch_reserve(swig_self(), n); }
inline bool vector_PhraseMatch::empty() const { return inworld_vector_PhraseMatch_empty(swig_self()); }
inline void vector_PhraseMatch::clear() { inworld_vector_PhraseMatch_clear(swig_self()); }
inline void vector_PhraseMatch::push_back(PhraseMatch const & x) { inworld_vector_PhraseMatch_push_back(swig_self(), x.swig_self()); }
inline PhraseMatch vector_PhraseMatch::get(int i) {
  auto swig_cres = inworld_vector_PhraseMatch_get(swig_self(), i);
  return PhraseMatch{swig_cres, false};
}
inline void vector_PhraseMatch::set(int i, PhraseMatch const & arg3) { inworld_vector_PhraseMatch_set(swig_self(), i, arg3.swig_self()); }
inline vector_KnowledgeRecord::vector_KnowledgeRecord() : vector_KnowledgeRecord{inworld_vector_KnowledgeRecord_new()} {}
inline vector_KnowledgeRecord::vector_KnowledgeRecord(vector_KnowledgeRecord const & other) : vector_KnowledgeRecord{inworld_vector_KnowledgeRecord_copy(other.swig_self())} {}
inline size_t vector_KnowledgeRecord::size() const { return inworld_vector_KnowledgeRecord_size(swig_self()); }
inline size_t vector_KnowledgeRecord::capacity() const { return inworld_vector_KnowledgeRecord_capacity(swig_self()); }
inline void vector_KnowledgeRecord::reserve(size_t n) { inworld_vector_KnowledgeRecord_reserve(swig_self(), n); }
inline bool vector_KnowledgeRecord::empty() const { return inworld_vector_KnowledgeRecord_empty(swig_self()); }
inline void vector_KnowledgeRecord::clear() { inworld_vector_KnowledgeRecord_clear(swig_self()); }
inline void vector_KnowledgeRecord::push_back(KnowledgeRecord const & x) { inworld_vector_KnowledgeRecord_push_back(swig_self(), x.swig_self()); }
inline KnowledgeRecord vector_KnowledgeRecord::get(int i) {
  auto swig_cres = inworld_vector_KnowledgeRecord_get(swig_self(), i);
  return KnowledgeRecord{swig_cres, false};
}
inline void vector_KnowledgeRecord::set(int i, KnowledgeRecord const & arg3) { inworld_vector_KnowledgeRecord_set(swig_self(), i, arg3.swig_self()); }
inline vector_KnowledgeCollection::vector_KnowledgeCollection() : vector_KnowledgeCollection{inworld_vector_KnowledgeCollection_new()} {}
inline vector_KnowledgeCollection::vector_KnowledgeCollection(vector_KnowledgeCollection const & other) : vector_KnowledgeCollection{inworld_vector_KnowledgeCollection_copy(other.swig_self())} {}
inline size_t vector_KnowledgeCollection::size() const { return inworld_vector_KnowledgeCollection_size(swig_self()); }
inline size_t vector_KnowledgeCollection::capacity() const { return inworld_vector_KnowledgeCollection_capacity(swig_self()); }
inline void vector_KnowledgeCollection::reserve(size_t n) { inworld_vector_KnowledgeCollection_reserve(swig_self(), n); }
inline bool vector_KnowledgeCollection::empty() const { return inworld_vector_KnowledgeCollection_empty(swig_self()); }
inline void vector_KnowledgeCollection::clear() { inworld_vector_KnowledgeCollection_clear(swig_self()); }
inline void vector_KnowledgeCollection::push_back(KnowledgeCollection const & x) { inworld_vector_KnowledgeCollection_push_back(swig_self(), x.swig_self()); }
inline KnowledgeCollection vector_KnowledgeCollection::get(int i) {
  auto swig_cres = inworld_vector_KnowledgeCollection_get(swig_self(), i);
  return KnowledgeCollection{swig_cres, false};
}
inline void vector_KnowledgeCollection::set(int i, KnowledgeCollection const & arg3) { inworld_vector_KnowledgeCollection_set(swig_self(), i, arg3.swig_self()); }
inline vector_LLMRoutingConfig::vector_LLMRoutingConfig() : vector_LLMRoutingConfig{inworld_vector_LLMRoutingConfig_new()} {}
inline vector_LLMRoutingConfig::vector_LLMRoutingConfig(vector_LLMRoutingConfig const & other) : vector_LLMRoutingConfig{inworld_vector_LLMRoutingConfig_copy(other.swig_self())} {}
inline size_t vector_LLMRoutingConfig::size() const { return inworld_vector_LLMRoutingConfig_size(swig_self()); }
inline size_t vector_LLMRoutingConfig::capacity() const { return inworld_vector_LLMRoutingConfig_capacity(swig_self()); }
inline void vector_LLMRoutingConfig::reserve(size_t n) { inworld_vector_LLMRoutingConfig_reserve(swig_self(), n); }
inline bool vector_LLMRoutingConfig::empty() const { return inworld_vector_LLMRoutingConfig_empty(swig_self()); }
inline void vector_LLMRoutingConfig::clear() { inworld_vector_LLMRoutingConfig_clear(swig_self()); }
inline void vector_LLMRoutingConfig::push_back(LLMRoutingConfig const & x) { inworld_vector_LLMRoutingConfig_push_back(swig_self(), x.swig_self()); }
inline LLMRoutingConfig vector_LLMRoutingConfig::get(int i) {
  auto swig_cres = inworld_vector_LLMRoutingConfig_get(swig_self(), i);
  return LLMRoutingConfig{swig_cres, false};
}
inline void vector_LLMRoutingConfig::set(int i, LLMRoutingConfig const & arg3) { inworld_vector_LLMRoutingConfig_set(swig_self(), i, arg3.swig_self()); }
inline vector_TopicThreshold::vector_TopicThreshold() : vector_TopicThreshold{inworld_vector_TopicThreshold_new()} {}
inline vector_TopicThreshold::vector_TopicThreshold(vector_TopicThreshold const & other) : vector_TopicThreshold{inworld_vector_TopicThreshold_copy(other.swig_self())} {}
inline size_t vector_TopicThreshold::size() const { return inworld_vector_TopicThreshold_size(swig_self()); }
inline size_t vector_TopicThreshold::capacity() const { return inworld_vector_TopicThreshold_capacity(swig_self()); }
inline void vector_TopicThreshold::reserve(size_t n) { inworld_vector_TopicThreshold_reserve(swig_self(), n); }
inline bool vector_TopicThreshold::empty() const { return inworld_vector_TopicThreshold_empty(swig_self()); }
inline void vector_TopicThreshold::clear() { inworld_vector_TopicThreshold_clear(swig_self()); }
inline void vector_TopicThreshold::push_back(TopicThreshold const & x) { inworld_vector_TopicThreshold_push_back(swig_self(), x.swig_self()); }
inline TopicThreshold vector_TopicThreshold::get(int i) {
  auto swig_cres = inworld_vector_TopicThreshold_get(swig_self(), i);
  return TopicThreshold{swig_cres, false};
}
inline void vector_TopicThreshold::set(int i, TopicThreshold const & arg3) { inworld_vector_TopicThreshold_set(swig_self(), i, arg3.swig_self()); }
inline vector_DetectedTopic::vector_DetectedTopic() : vector_DetectedTopic{inworld_vector_DetectedTopic_new()} {}
inline vector_DetectedTopic::vector_DetectedTopic(vector_DetectedTopic const & other) : vector_DetectedTopic{inworld_vector_DetectedTopic_copy(other.swig_self())} {}
inline size_t vector_DetectedTopic::size() const { return inworld_vector_DetectedTopic_size(swig_self()); }
inline size_t vector_DetectedTopic::capacity() const { return inworld_vector_DetectedTopic_capacity(swig_self()); }
inline void vector_DetectedTopic::reserve(size_t n) { inworld_vector_DetectedTopic_reserve(swig_self(), n); }
inline bool vector_DetectedTopic::empty() const { return inworld_vector_DetectedTopic_empty(swig_self()); }
inline void vector_DetectedTopic::clear() { inworld_vector_DetectedTopic_clear(swig_self()); }
inline void vector_DetectedTopic::push_back(DetectedTopic const & x) { inworld_vector_DetectedTopic_push_back(swig_self(), x.swig_self()); }
inline DetectedTopic vector_DetectedTopic::get(int i) {
  auto swig_cres = inworld_vector_DetectedTopic_get(swig_self(), i);
  return DetectedTopic{swig_cres, false};
}
inline void vector_DetectedTopic::set(int i, DetectedTopic const & arg3) { inworld_vector_DetectedTopic_set(swig_self(), i, arg3.swig_self()); }
inline vector_DictionaryRule::vector_DictionaryRule() : vector_DictionaryRule{inworld_vector_DictionaryRule_new()} {}
inline vector_DictionaryRule::vector_DictionaryRule(vector_DictionaryRule const & other) : vector_DictionaryRule{inworld_vector_DictionaryRule_copy(other.swig_self())} {}
inline size_t vector_DictionaryRule::size() const { return inworld_vector_DictionaryRule_size(swig_self()); }
inline size_t vector_DictionaryRule::capacity() const { return inworld_vector_DictionaryRule_capacity(swig_self()); }
inline void vector_DictionaryRule::reserve(size_t n) { inworld_vector_DictionaryRule_reserve(swig_self(), n); }
inline bool vector_DictionaryRule::empty() const { return inworld_vector_DictionaryRule_empty(swig_self()); }
inline void vector_DictionaryRule::clear() { inworld_vector_DictionaryRule_clear(swig_self()); }
inline void vector_DictionaryRule::push_back(DictionaryRule const & x) { inworld_vector_DictionaryRule_push_back(swig_self(), x.swig_self()); }
inline DictionaryRule vector_DictionaryRule::get(int i) {
  auto swig_cres = inworld_vector_DictionaryRule_get(swig_self(), i);
  return DictionaryRule{swig_cres, false};
}
inline void vector_DictionaryRule::set(int i, DictionaryRule const & arg3) { inworld_vector_DictionaryRule_set(swig_self(), i, arg3.swig_self()); }
inline vector_Entity::vector_Entity() : vector_Entity{inworld_vector_Entity_new()} {}
inline vector_Entity::vector_Entity(vector_Entity const & other) : vector_Entity{inworld_vector_Entity_copy(other.swig_self())} {}
inline size_t vector_Entity::size() const { return inworld_vector_Entity_size(swig_self()); }
inline size_t vector_Entity::capacity() const { return inworld_vector_Entity_capacity(swig_self()); }
inline void vector_Entity::reserve(size_t n) { inworld_vector_Entity_reserve(swig_self(), n); }
inline bool vector_Entity::empty() const { return inworld_vector_Entity_empty(swig_self()); }
inline void vector_Entity::clear() { inworld_vector_Entity_clear(swig_self()); }
inline void vector_Entity::push_back(Entity const & x) { inworld_vector_Entity_push_back(swig_self(), x.swig_self()); }
inline Entity vector_Entity::get(int i) {
  auto swig_cres = inworld_vector_Entity_get(swig_self(), i);
  return Entity{swig_cres, false};
}
inline void vector_Entity::set(int i, Entity const & arg3) { inworld_vector_Entity_set(swig_self(), i, arg3.swig_self()); }
inline vector_EntityMatch::vector_EntityMatch() : vector_EntityMatch{inworld_vector_EntityMatch_new()} {}
inline vector_EntityMatch::vector_EntityMatch(vector_EntityMatch const & other) : vector_EntityMatch{inworld_vector_EntityMatch_copy(other.swig_self())} {}
inline size_t vector_EntityMatch::size() const { return inworld_vector_EntityMatch_size(swig_self()); }
inline size_t vector_EntityMatch::capacity() const { return inworld_vector_EntityMatch_capacity(swig_self()); }
inline void vector_EntityMatch::reserve(size_t n) { inworld_vector_EntityMatch_reserve(swig_self(), n); }
inline bool vector_EntityMatch::empty() const { return inworld_vector_EntityMatch_empty(swig_self()); }
inline void vector_EntityMatch::clear() { inworld_vector_EntityMatch_clear(swig_self()); }
inline void vector_EntityMatch::push_back(EntityMatch const & x) { inworld_vector_EntityMatch_push_back(swig_self(), x.swig_self()); }
inline EntityMatch vector_EntityMatch::get(int i) {
  auto swig_cres = inworld_vector_EntityMatch_get(swig_self(), i);
  return EntityMatch{swig_cres, false};
}
inline void vector_EntityMatch::set(int i, EntityMatch const & arg3) { inworld_vector_EntityMatch_set(swig_self(), i, arg3.swig_self()); }
inline vector_vector_float::vector_vector_float() : vector_vector_float{inworld_vector_vector_float_new()} {}
inline vector_vector_float::vector_vector_float(vector_vector_float const & other) : vector_vector_float{inworld_vector_vector_float_copy(other.swig_self())} {}
inline size_t vector_vector_float::size() const { return inworld_vector_vector_float_size(swig_self()); }
inline size_t vector_vector_float::capacity() const { return inworld_vector_vector_float_capacity(swig_self()); }
inline void vector_vector_float::reserve(size_t n) { inworld_vector_vector_float_reserve(swig_self(), n); }
inline bool vector_vector_float::empty() const { return inworld_vector_vector_float_empty(swig_self()); }
inline void vector_vector_float::clear() { inworld_vector_vector_float_clear(swig_self()); }
inline void vector_vector_float::push_back(vector_float const & x) { inworld_vector_vector_float_push_back(swig_self(), x.swig_self()); }
inline vector_float vector_vector_float::get(int i) {
  auto swig_cres = inworld_vector_vector_float_get(swig_self(), i);
  return vector_float{swig_cres, false};
}
inline void vector_vector_float::set(int i, vector_float const & arg3) { inworld_vector_vector_float_set(swig_self(), i, arg3.swig_self()); }
inline vector_string::vector_string() : vector_string{inworld_vector_string_new()} {}
inline vector_string::vector_string(vector_string const & other) : vector_string{inworld_vector_string_copy(other.swig_self())} {}
inline size_t vector_string::size() const { return inworld_vector_string_size(swig_self()); }
inline size_t vector_string::capacity() const { return inworld_vector_string_capacity(swig_self()); }
inline void vector_string::reserve(size_t n) { inworld_vector_string_reserve(swig_self(), n); }
inline bool vector_string::empty() const { return inworld_vector_string_empty(swig_self()); }
inline void vector_string::clear() { inworld_vector_string_clear(swig_self()); }
inline void vector_string::push_back(std::string const& x) { inworld_vector_string_push_back(swig_self(), (&x)->c_str()); }
inline std::string vector_string::get(int i) {
  auto swig_cres = inworld_vector_string_get(swig_self(), i);
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void vector_string::set(int i, std::string const& arg3) { inworld_vector_string_set(swig_self(), i, (&arg3)->c_str()); }
inline vector_map_string_string::vector_map_string_string() : vector_map_string_string{inworld_vector_map_string_string_new()} {}
inline vector_map_string_string::vector_map_string_string(vector_map_string_string const & other) : vector_map_string_string{inworld_vector_map_string_string_copy(other.swig_self())} {}
inline size_t vector_map_string_string::size() const { return inworld_vector_map_string_string_size(swig_self()); }
inline size_t vector_map_string_string::capacity() const { return inworld_vector_map_string_string_capacity(swig_self()); }
inline void vector_map_string_string::reserve(size_t n) { inworld_vector_map_string_string_reserve(swig_self(), n); }
inline bool vector_map_string_string::empty() const { return inworld_vector_map_string_string_empty(swig_self()); }
inline void vector_map_string_string::clear() { inworld_vector_map_string_string_clear(swig_self()); }
inline void vector_map_string_string::push_back(map_string_string const & x) { inworld_vector_map_string_string_push_back(swig_self(), x.swig_self()); }
inline map_string_string vector_map_string_string::get(int i) {
  auto swig_cres = inworld_vector_map_string_string_get(swig_self(), i);
  return map_string_string{swig_cres, false};
}
inline void vector_map_string_string::set(int i, map_string_string const & arg3) { inworld_vector_map_string_string_set(swig_self(), i, arg3.swig_self()); }
inline map_string_string::map_string_string() : map_string_string{inworld_map_string_string_new()} {}
inline map_string_string::map_string_string(map_string_string const & other) : map_string_string{inworld_map_string_string_copy(other.swig_self())} {}
inline size_t map_string_string::size() const { return inworld_map_string_string_size(swig_self()); }
inline bool map_string_string::empty() const { return inworld_map_string_string_empty(swig_self()); }
inline void map_string_string::clear() { inworld_map_string_string_clear(swig_self()); }
inline std::string map_string_string::get(std::string const& key) {
  auto swig_cres = inworld_map_string_string_get(swig_self(), (&key)->c_str());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void map_string_string::set(std::string const& key, std::string const& arg3) { inworld_map_string_string_set(swig_self(), (&key)->c_str(), (&arg3)->c_str()); }
inline void map_string_string::del(std::string const& key) { inworld_map_string_string_del(swig_self(), (&key)->c_str()); }
inline bool map_string_string::has_key(std::string const& key) const { return inworld_map_string_string_has_key(swig_self(), (&key)->c_str()); }
inline optional_BatchProcessingOptions::optional_BatchProcessingOptions() : optional_BatchProcessingOptions{inworld_optional_BatchProcessingOptions_new()} {}
inline optional_BatchProcessingOptions::optional_BatchProcessingOptions(BatchProcessingOptions const & value) : optional_BatchProcessingOptions{inworld_optional_BatchProcessingOptions_new_rcinworld_BatchProcessingOptions(value.swig_self())} {}
inline optional_BatchProcessingOptions::optional_BatchProcessingOptions(optional_BatchProcessingOptions const & other) : optional_BatchProcessingOptions{inworld_optional_BatchProcessingOptions_copy(other.swig_self())} {}
inline bool optional_BatchProcessingOptions::has_value() const { return inworld_optional_BatchProcessingOptions_has_value(swig_self()); }
inline BatchProcessingOptions optional_BatchProcessingOptions::value() {
  auto swig_cres = inworld_optional_BatchProcessingOptions_value(swig_self());
  return BatchProcessingOptions{swig_cres, false};
}
inline BatchProcessingOptions optional_BatchProcessingOptions::value() const {
  auto swig_cres = inworld_optional_BatchProcessingOptions_valueConst(swig_self());
  return BatchProcessingOptions{swig_cres, false};
}
inline BatchProcessingOptions optional_BatchProcessingOptions::value_or(BatchProcessingOptions const & default_value) const {
  auto swig_cres = inworld_optional_BatchProcessingOptions_value_or(swig_self(), default_value.swig_self());
  return BatchProcessingOptions{swig_cres, true};
}
inline void optional_BatchProcessingOptions::reset() { inworld_optional_BatchProcessingOptions_reset(swig_self()); }
inline BatchProcessingOptions optional_BatchProcessingOptions::operator *() {
  auto swig_cres = inworld_optional_BatchProcessingOptions_get(swig_self());
  return BatchProcessingOptions{swig_cres, false};
}
inline BatchProcessingOptions optional_BatchProcessingOptions::operator *() const {
  auto swig_cres = inworld_optional_BatchProcessingOptions_getConst(swig_self());
  return BatchProcessingOptions{swig_cres, false};
}
inline BatchProcessingOptions optional_BatchProcessingOptions::get_value() {
  auto swig_cres = inworld_optional_BatchProcessingOptions_get_value(swig_self());
  return BatchProcessingOptions{swig_cres, false};
}
inline void optional_BatchProcessingOptions::set_value(BatchProcessingOptions & t) { inworld_optional_BatchProcessingOptions_set_value(swig_self(), t.swig_self()); }
inline void Span::SetAttribute(std::string const& key, std::string const& arg3) { inworld_Span_SetAttribute_rcstd_string_rcstd_string(swig_self(), (&key)->c_str(), (&arg3)->c_str()); }
inline void Span::SetAttribute(std::string const& key, vector_string const & arg3) { inworld_Span_SetAttribute_rcstd_string_rcstd_vector_Sl_std_string_Sg_(swig_self(), (&key)->c_str(), arg3.swig_self()); }
inline void Span::SetOK() { inworld_Span_SetOK(swig_self()); }
inline void Span::SetError(std::string const& description) { inworld_Span_SetError(swig_self(), (&description)->c_str()); }
inline void Span::End() { inworld_Span_End(swig_self()); }
inline void SpanDataEvent::name(std::string const& name) { inworld_SpanDataEvent_name_set(swig_self(), (&name)->c_str()); }
inline std::string SpanDataEvent::name() const {
  auto swig_cres = inworld_SpanDataEvent_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void SpanDataEvent::timestampInNanos(long long timestampInNanos) { inworld_SpanDataEvent_timestampInNanos_set(swig_self(), timestampInNanos); }
inline long long SpanDataEvent::timestampInNanos() const { return inworld_SpanDataEvent_timestampInNanos_get(swig_self()); }
inline void SpanDataEvent::attributes(map_string_string * attributes) { inworld_SpanDataEvent_attributes_set(swig_self(), attributes->swig_self()); }
inline map_string_string * SpanDataEvent::attributes() const {
  auto swig_cres = inworld_SpanDataEvent_attributes_get(swig_self());
  return swig_cres ? new map_string_string(swig_cres, false) : nullptr;
}
inline SpanDataEvent::SpanDataEvent() : SpanDataEvent{inworld_SpanDataEvent_new()} {}
inline SpanDataEvent::SpanDataEvent(SpanDataEvent const & other) : SpanDataEvent{inworld_SpanDataEvent_copy(other.swig_self())} {}
inline std::string SpanData::GetTraceId() const {
  auto swig_cres = inworld_SpanData_GetTraceId(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline std::string SpanData::GetSpanId() const {
  auto swig_cres = inworld_SpanData_GetSpanId(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline std::string SpanData::GetParentSpanId() const {
  auto swig_cres = inworld_SpanData_GetParentSpanId(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline std::string SpanData::GetName() const {
  auto swig_cres = inworld_SpanData_GetName(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline std::string SpanData::GetDescription() const {
  auto swig_cres = inworld_SpanData_GetDescription(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline long long SpanData::GetStartTimeInNanos() const { return inworld_SpanData_GetStartTimeInNanos(swig_self()); }
inline long long SpanData::GetDurationInNanos() const { return inworld_SpanData_GetDurationInNanos(swig_self()); }
inline std::string SpanData::GetSpanKind() const {
  auto swig_cres = inworld_SpanData_GetSpanKind(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline std::string SpanData::GetStatus() const {
  auto swig_cres = inworld_SpanData_GetStatus(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline map_string_string SpanData::GetAttributes() const {
  auto swig_cres = inworld_SpanData_GetAttributes(swig_self());
  return map_string_string{swig_cres, true};
}
inline vector_SpanDataEvent SpanData::GetEvents() const {
  auto swig_cres = inworld_SpanData_GetEvents(swig_self());
  return vector_SpanDataEvent{swig_cres, true};
}
inline std::string GenerateExecutionId() {
  auto swig_cres = inworld_GenerateExecutionId();
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline Span StartSpan(std::string const& name) {
  auto swig_cres = inworld_StartSpan_rcstd_string((&name)->c_str());
  return Span{swig_cres, true};
}
inline Span StartSpan(std::string const& name, map_string_string const & arg2) {
  auto swig_cres = inworld_StartSpan_rcstd_string_rcstd_map_Sl_std_string_Sc_std_string_Sg_((&name)->c_str(), arg2.swig_self());
  return Span{swig_cres, true};
}
inline Span StartSpan(std::string const& name, map_string_string & arg2, vector_TelemetrySpan const & arg3, Span const & arg4) {
  auto swig_cres = inworld_StartSpan_rcstd_string_rstd_map_Sl_std_string_Sc_std_string_Sg__rcstd_vector_Sl_inworld_telemetry_Span_Sg__rcinworld_telemetry_Span((&name)->c_str(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return Span{swig_cres, true};
}
inline vector_SpanData DequeueSpanTraces(size_t count) {
  auto swig_cres = inworld_DequeueSpanTraces(count);
  return vector_SpanData{swig_cres, true};
}
inline char * kTelemetryApiKey() { return inworld_kTelemetryApiKey_get(); }
inline char * kTelemetryEndpoint() { return inworld_kTelemetryEndpoint_get(); }
inline char * kTelemetryDontGreet() { return inworld_kTelemetryDontGreet_get(); }
inline void BatchProcessingOptions::max_queue_size(size_t max_queue_size) { inworld_BatchProcessingOptions_max_queue_size_set(swig_self(), max_queue_size); }
inline size_t BatchProcessingOptions::max_queue_size() const { return inworld_BatchProcessingOptions_max_queue_size_get(swig_self()); }
inline void BatchProcessingOptions::max_export_batch_size(size_t max_export_batch_size) { inworld_BatchProcessingOptions_max_export_batch_size_set(swig_self(), max_export_batch_size); }
inline size_t BatchProcessingOptions::max_export_batch_size() const { return inworld_BatchProcessingOptions_max_export_batch_size_get(swig_self()); }
inline BatchProcessingOptions::BatchProcessingOptions() : BatchProcessingOptions{inworld_BatchProcessingOptions_new()} {}
inline BatchProcessingOptions::BatchProcessingOptions(BatchProcessingOptions const & other) : BatchProcessingOptions{inworld_BatchProcessingOptions_copy(other.swig_self())} {}
inline void TracerConfig::sampling_rate(double sampling_rate) { inworld_TracerConfig_sampling_rate_set(swig_self(), sampling_rate); }
inline double TracerConfig::sampling_rate() const { return inworld_TracerConfig_sampling_rate_get(swig_self()); }
inline void TracerConfig::span_dump_path(std::string const& span_dump_path) { inworld_TracerConfig_span_dump_path_set(swig_self(), (&span_dump_path)->c_str()); }
inline std::string TracerConfig::span_dump_path() const {
  auto swig_cres = inworld_TracerConfig_span_dump_path_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void TracerConfig::batch_processing_opts(optional_BatchProcessingOptions * batch_processing_opts) { inworld_TracerConfig_batch_processing_opts_set(swig_self(), batch_processing_opts->swig_self()); }
inline optional_BatchProcessingOptions * TracerConfig::batch_processing_opts() const {
  auto swig_cres = inworld_TracerConfig_batch_processing_opts_get(swig_self());
  return swig_cres ? new optional_BatchProcessingOptions(swig_cres, false) : nullptr;
}
inline void TracerConfig::enable_span_capture(bool enable_span_capture) { inworld_TracerConfig_enable_span_capture_set(swig_self(), enable_span_capture); }
inline bool TracerConfig::enable_span_capture() const { return inworld_TracerConfig_enable_span_capture_get(swig_self()); }
inline void TracerConfig::max_queue_size(size_t max_queue_size) { inworld_TracerConfig_max_queue_size_set(swig_self(), max_queue_size); }
inline size_t TracerConfig::max_queue_size() const { return inworld_TracerConfig_max_queue_size_get(swig_self()); }
inline TracerConfig::TracerConfig() : TracerConfig{inworld_TracerConfig_new()} {}
inline TracerConfig::TracerConfig(TracerConfig const & other) : TracerConfig{inworld_TracerConfig_copy(other.swig_self())} {}
inline void LoggerConfig::log_level(LogLevel log_level) { inworld_LoggerConfig_log_level_set(swig_self(), (inworld_LogLevel)log_level); }
inline LogLevel LoggerConfig::log_level() const {
  auto swig_cres = inworld_LoggerConfig_log_level_get(swig_self());
  return (LogLevel)swig_cres;
}
inline void LoggerConfig::sink_absl_logs(bool sink_absl_logs) { inworld_LoggerConfig_sink_absl_logs_set(swig_self(), sink_absl_logs); }
inline bool LoggerConfig::sink_absl_logs() const { return inworld_LoggerConfig_sink_absl_logs_get(swig_self()); }
inline void LoggerConfig::batch_processing_opts(optional_BatchProcessingOptions * batch_processing_opts) { inworld_LoggerConfig_batch_processing_opts_set(swig_self(), batch_processing_opts->swig_self()); }
inline optional_BatchProcessingOptions * LoggerConfig::batch_processing_opts() const {
  auto swig_cres = inworld_LoggerConfig_batch_processing_opts_get(swig_self());
  return swig_cres ? new optional_BatchProcessingOptions(swig_cres, false) : nullptr;
}
inline LoggerConfig::LoggerConfig() : LoggerConfig{inworld_LoggerConfig_new()} {}
inline LoggerConfig::LoggerConfig(LoggerConfig const & other) : LoggerConfig{inworld_LoggerConfig_copy(other.swig_self())} {}
inline void MetricConfig::metric_type(MetricConfig::MetricType metric_type) { inworld_MetricConfig_metric_type_set(swig_self(), (inworld_MetricConfig_MetricType)metric_type); }
inline MetricConfig::MetricType MetricConfig::metric_type() const {
  auto swig_cres = inworld_MetricConfig_metric_type_get(swig_self());
  return (MetricConfig::MetricType)swig_cres;
}
inline void MetricConfig::name(std::string const& name) { inworld_MetricConfig_name_set(swig_self(), (&name)->c_str()); }
inline std::string MetricConfig::name() const {
  auto swig_cres = inworld_MetricConfig_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void MetricConfig::description(std::string const& description) { inworld_MetricConfig_description_set(swig_self(), (&description)->c_str()); }
inline std::string MetricConfig::description() const {
  auto swig_cres = inworld_MetricConfig_description_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void MetricConfig::unit(std::string const& unit) { inworld_MetricConfig_unit_set(swig_self(), (&unit)->c_str()); }
inline std::string MetricConfig::unit() const {
  auto swig_cres = inworld_MetricConfig_unit_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline MetricConfig::MetricConfig() : MetricConfig{inworld_MetricConfig_new()} {}
inline MetricConfig::MetricConfig(MetricConfig const & other) : MetricConfig{inworld_MetricConfig_copy(other.swig_self())} {}
inline void TelemetryConfig::tracer(TracerConfig * tracer) { inworld_TelemetryConfig_tracer_set(swig_self(), tracer->swig_self()); }
inline TracerConfig * TelemetryConfig::tracer() const {
  auto swig_cres = inworld_TelemetryConfig_tracer_get(swig_self());
  return swig_cres ? new TracerConfig(swig_cres, false) : nullptr;
}
inline void TelemetryConfig::logger(LoggerConfig * logger) { inworld_TelemetryConfig_logger_set(swig_self(), logger->swig_self()); }
inline LoggerConfig * TelemetryConfig::logger() const {
  auto swig_cres = inworld_TelemetryConfig_logger_get(swig_self());
  return swig_cres ? new LoggerConfig(swig_cres, false) : nullptr;
}
inline void TelemetryConfig::service_name(std::string const& service_name) { inworld_TelemetryConfig_service_name_set(swig_self(), (&service_name)->c_str()); }
inline std::string TelemetryConfig::service_name() const {
  auto swig_cres = inworld_TelemetryConfig_service_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void TelemetryConfig::service_version(std::string const& service_version) { inworld_TelemetryConfig_service_version_set(swig_self(), (&service_version)->c_str()); }
inline std::string TelemetryConfig::service_version() const {
  auto swig_cres = inworld_TelemetryConfig_service_version_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void TelemetryConfig::endpoint(std::string const& endpoint) { inworld_TelemetryConfig_endpoint_set(swig_self(), (&endpoint)->c_str()); }
inline std::string TelemetryConfig::endpoint() const {
  auto swig_cres = inworld_TelemetryConfig_endpoint_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void TelemetryConfig::api_key(std::string const& api_key) { inworld_TelemetryConfig_api_key_set(swig_self(), (&api_key)->c_str()); }
inline std::string TelemetryConfig::api_key() const {
  auto swig_cres = inworld_TelemetryConfig_api_key_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void TelemetryConfig::exporter_type(ExporterType exporter_type) { inworld_TelemetryConfig_exporter_type_set(swig_self(), (inworld_ExporterType)exporter_type); }
inline ExporterType TelemetryConfig::exporter_type() const {
  auto swig_cres = inworld_TelemetryConfig_exporter_type_get(swig_self());
  return (ExporterType)swig_cres;
}
inline void TelemetryConfig::sdk_name(std::string const& sdk_name) { inworld_TelemetryConfig_sdk_name_set(swig_self(), (&sdk_name)->c_str()); }
inline std::string TelemetryConfig::sdk_name() const {
  auto swig_cres = inworld_TelemetryConfig_sdk_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void TelemetryConfig::sdk_version(std::string const& sdk_version) { inworld_TelemetryConfig_sdk_version_set(swig_self(), (&sdk_version)->c_str()); }
inline std::string TelemetryConfig::sdk_version() const {
  auto swig_cres = inworld_TelemetryConfig_sdk_version_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline TelemetryConfig::TelemetryConfig() : TelemetryConfig{inworld_TelemetryConfig_new()} {}
inline TelemetryConfig::TelemetryConfig(TelemetryConfig const & other) : TelemetryConfig{inworld_TelemetryConfig_copy(other.swig_self())} {}
inline TelemetryConfigBuilder::TelemetryConfigBuilder() : TelemetryConfigBuilder{inworld_TelemetryConfigBuilder_new()} {}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetServiceName(std::string const& name) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetServiceName(swig_self(), (&name)->c_str());
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetServiceVersion(std::string const& version) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetServiceVersion(swig_self(), (&version)->c_str());
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetExporterType(ExporterType type) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetExporterType(swig_self(), (inworld_ExporterType)type);
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetSdkName(std::string const& name) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetSdkName(swig_self(), (&name)->c_str());
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetSdkVersion(std::string const& version) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetSdkVersion(swig_self(), (&version)->c_str());
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetEndpoint(std::string const& new_endpoint) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetEndpoint(swig_self(), (&new_endpoint)->c_str());
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetApiKey(std::string const& api_key) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetApiKey(swig_self(), (&api_key)->c_str());
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetSinkAbslLogs(bool sink_absl_logs) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetSinkAbslLogs(swig_self(), sink_absl_logs);
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetSamplingRate(double rate) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetSamplingRate(swig_self(), rate);
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetLogLevel(LogLevel level) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetLogLevel(swig_self(), (inworld_LogLevel)level);
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfigBuilder TelemetryConfigBuilder::SetSpanDumpPath(std::string const& path) {
  auto swig_cres = inworld_TelemetryConfigBuilder_SetSpanDumpPath(swig_self(), (&path)->c_str());
  return TelemetryConfigBuilder{swig_cres, false};
}
inline TelemetryConfig TelemetryConfigBuilder::Build() const {
  auto swig_cres = inworld_TelemetryConfigBuilder_Build(swig_self());
  return TelemetryConfig{swig_cres, true};
}
inline TelemetryConfigBuilder::TelemetryConfigBuilder(TelemetryConfigBuilder const & other) : TelemetryConfigBuilder{inworld_TelemetryConfigBuilder_copy(other.swig_self())} {}
inline void ConfigureTelemetry(TelemetryConfig const & config) { inworld_ConfigureTelemetry_rcinworld_TelemetryConfig(config.swig_self()); }
inline void ConfigureTelemetry(std::string const& service_name, std::string const& arg2) { inworld_ConfigureTelemetry_rcstd_string_rcstd_string((&service_name)->c_str(), (&arg2)->c_str()); }
inline void ShutdownTelemetry() { inworld_ShutdownTelemetry(); }
inline void ConfigureMetric(MetricConfig const & config) { inworld_ConfigureMetric(config.swig_self()); }
inline void RecordCounterUInt(std::string const& name, unsigned long long arg2, map_string_string const & arg3) { inworld_RecordCounterUInt_rcstd_string_unsigned_SS_long_SS_long_rcstd_map_Sl_std_string_Sc_std_string_Sg_((&name)->c_str(), arg2, arg3.swig_self()); }
inline void RecordCounterUInt(std::string const& name, unsigned long long arg2) { inworld_RecordCounterUInt_rcstd_string_unsigned_SS_long_SS_long((&name)->c_str(), arg2); }
inline void RecordCounterDouble(std::string const& name, double arg2, map_string_string const & arg3) { inworld_RecordCounterDouble_rcstd_string_d_rcstd_map_Sl_std_string_Sc_std_string_Sg_((&name)->c_str(), arg2, arg3.swig_self()); }
inline void RecordCounterDouble(std::string const& name, double arg2) { inworld_RecordCounterDouble_rcstd_string_d((&name)->c_str(), arg2); }
inline void RecordGaugeInt(std::string const& name, long long arg2, map_string_string const & arg3) { inworld_RecordGaugeInt_rcstd_string_long_SS_long_rcstd_map_Sl_std_string_Sc_std_string_Sg_((&name)->c_str(), arg2, arg3.swig_self()); }
inline void RecordGaugeInt(std::string const& name, long long arg2) { inworld_RecordGaugeInt_rcstd_string_long_SS_long((&name)->c_str(), arg2); }
inline void RecordGaugeDouble(std::string const& name, double arg2, map_string_string const & arg3) { inworld_RecordGaugeDouble_rcstd_string_d_rcstd_map_Sl_std_string_Sc_std_string_Sg_((&name)->c_str(), arg2, arg3.swig_self()); }
inline void RecordGaugeDouble(std::string const& name, double arg2) { inworld_RecordGaugeDouble_rcstd_string_d((&name)->c_str(), arg2); }
inline void RecordHistogramUInt(std::string const& name, unsigned long long arg2, map_string_string const & arg3) { inworld_RecordHistogramUInt_rcstd_string_unsigned_SS_long_SS_long_rcstd_map_Sl_std_string_Sc_std_string_Sg_((&name)->c_str(), arg2, arg3.swig_self()); }
inline void RecordHistogramUInt(std::string const& name, unsigned long long arg2) { inworld_RecordHistogramUInt_rcstd_string_unsigned_SS_long_SS_long((&name)->c_str(), arg2); }
inline void RecordHistogramDouble(std::string const& name, double arg2, map_string_string const & arg3) { inworld_RecordHistogramDouble_rcstd_string_d_rcstd_map_Sl_std_string_Sc_std_string_Sg_((&name)->c_str(), arg2, arg3.swig_self()); }
inline void RecordHistogramDouble(std::string const& name, double arg2) { inworld_RecordHistogramDouble_rcstd_string_d((&name)->c_str(), arg2); }
inline void LogMessage(LogLevel level, std::string const& arg2, map_string_string const & arg3) { inworld_LogMessage_eLogLevel_rcstd_string_rcstd_map_Sl_std_string_Sc_std_string_Sg_((inworld_LogLevel)level, (&arg2)->c_str(), arg3.swig_self()); }
inline void LogMessage(LogLevel level, std::string const& arg2) { inworld_LogMessage_eLogLevel_rcstd_string((inworld_LogLevel)level, (&arg2)->c_str()); }
inline void LogMessage(LogLevel level, std::string const& arg2, ProcessContext const & arg3, map_string_string const & arg4) { inworld_LogMessage_eLogLevel_rcstd_string_rcinworld_graphs_ProcessContext_rcstd_map_Sl_std_string_Sc_std_string_Sg_((inworld_LogLevel)level, (&arg2)->c_str(), arg3.swig_self(), arg4.swig_self()); }
inline void LogMessage(LogLevel level, std::string const& arg2, ProcessContext const & arg3) { inworld_LogMessage_eLogLevel_rcstd_string_rcinworld_graphs_ProcessContext((inworld_LogLevel)level, (&arg2)->c_str(), arg3.swig_self()); }
inline vector_TelemetrySpan::vector_TelemetrySpan() : vector_TelemetrySpan{inworld_vector_TelemetrySpan_new()} {}
inline vector_TelemetrySpan::vector_TelemetrySpan(vector_TelemetrySpan const & other) : vector_TelemetrySpan{inworld_vector_TelemetrySpan_copy(other.swig_self())} {}
inline size_t vector_TelemetrySpan::size() const { return inworld_vector_TelemetrySpan_size(swig_self()); }
inline size_t vector_TelemetrySpan::capacity() const { return inworld_vector_TelemetrySpan_capacity(swig_self()); }
inline void vector_TelemetrySpan::reserve(size_t n) { inworld_vector_TelemetrySpan_reserve(swig_self(), n); }
inline bool vector_TelemetrySpan::empty() const { return inworld_vector_TelemetrySpan_empty(swig_self()); }
inline void vector_TelemetrySpan::clear() { inworld_vector_TelemetrySpan_clear(swig_self()); }
inline void vector_TelemetrySpan::push_back(Span const & x) { inworld_vector_TelemetrySpan_push_back(swig_self(), x.swig_self()); }
inline Span vector_TelemetrySpan::get(int i) {
  auto swig_cres = inworld_vector_TelemetrySpan_get(swig_self(), i);
  return Span{swig_cres, false};
}
inline void vector_TelemetrySpan::set(int i, Span const & arg3) { inworld_vector_TelemetrySpan_set(swig_self(), i, arg3.swig_self()); }
inline vector_SpanData::vector_SpanData() : vector_SpanData{inworld_vector_SpanData_new()} {}
inline vector_SpanData::vector_SpanData(vector_SpanData const & other) : vector_SpanData{inworld_vector_SpanData_copy(other.swig_self())} {}
inline size_t vector_SpanData::size() const { return inworld_vector_SpanData_size(swig_self()); }
inline size_t vector_SpanData::capacity() const { return inworld_vector_SpanData_capacity(swig_self()); }
inline void vector_SpanData::reserve(size_t n) { inworld_vector_SpanData_reserve(swig_self(), n); }
inline bool vector_SpanData::empty() const { return inworld_vector_SpanData_empty(swig_self()); }
inline void vector_SpanData::clear() { inworld_vector_SpanData_clear(swig_self()); }
inline void vector_SpanData::push_back(SpanData const & x) { inworld_vector_SpanData_push_back(swig_self(), x.swig_self()); }
inline SpanData vector_SpanData::get(int i) {
  auto swig_cres = inworld_vector_SpanData_get(swig_self(), i);
  return SpanData{swig_cres, false};
}
inline void vector_SpanData::set(int i, SpanData const & arg3) { inworld_vector_SpanData_set(swig_self(), i, arg3.swig_self()); }
inline vector_SpanDataEvent::vector_SpanDataEvent() : vector_SpanDataEvent{inworld_vector_SpanDataEvent_new()} {}
inline vector_SpanDataEvent::vector_SpanDataEvent(vector_SpanDataEvent const & other) : vector_SpanDataEvent{inworld_vector_SpanDataEvent_copy(other.swig_self())} {}
inline size_t vector_SpanDataEvent::size() const { return inworld_vector_SpanDataEvent_size(swig_self()); }
inline size_t vector_SpanDataEvent::capacity() const { return inworld_vector_SpanDataEvent_capacity(swig_self()); }
inline void vector_SpanDataEvent::reserve(size_t n) { inworld_vector_SpanDataEvent_reserve(swig_self(), n); }
inline bool vector_SpanDataEvent::empty() const { return inworld_vector_SpanDataEvent_empty(swig_self()); }
inline void vector_SpanDataEvent::clear() { inworld_vector_SpanDataEvent_clear(swig_self()); }
inline void vector_SpanDataEvent::push_back(SpanDataEvent const & x) { inworld_vector_SpanDataEvent_push_back(swig_self(), x.swig_self()); }
inline SpanDataEvent vector_SpanDataEvent::get(int i) {
  auto swig_cres = inworld_vector_SpanDataEvent_get(swig_self(), i);
  return SpanDataEvent{swig_cres, false};
}
inline void vector_SpanDataEvent::set(int i, SpanDataEvent const & arg3) { inworld_vector_SpanDataEvent_set(swig_self(), i, arg3.swig_self()); }
inline vector_Edge::vector_Edge() : vector_Edge{inworld_vector_Edge_new()} {}
inline vector_Edge::vector_Edge(vector_Edge const & other) : vector_Edge{inworld_vector_Edge_copy(other.swig_self())} {}
inline size_t vector_Edge::size() const { return inworld_vector_Edge_size(swig_self()); }
inline size_t vector_Edge::capacity() const { return inworld_vector_Edge_capacity(swig_self()); }
inline void vector_Edge::reserve(size_t n) { inworld_vector_Edge_reserve(swig_self(), n); }
inline bool vector_Edge::empty() const { return inworld_vector_Edge_empty(swig_self()); }
inline void vector_Edge::clear() { inworld_vector_Edge_clear(swig_self()); }
inline void vector_Edge::push_back(Edge const & x) { inworld_vector_Edge_push_back(swig_self(), x.swig_self()); }
inline Edge vector_Edge::get(int i) {
  auto swig_cres = inworld_vector_Edge_get(swig_self(), i);
  return Edge{swig_cres, false};
}
inline void vector_Edge::set(int i, Edge const & arg3) { inworld_vector_Edge_set(swig_self(), i, arg3.swig_self()); }
inline vector_char::vector_char() : vector_char{inworld_vector_char_new()} {}
inline vector_char::vector_char(vector_char const & other) : vector_char{inworld_vector_char_copy(other.swig_self())} {}
inline size_t vector_char::size() const { return inworld_vector_char_size(swig_self()); }
inline size_t vector_char::capacity() const { return inworld_vector_char_capacity(swig_self()); }
inline void vector_char::reserve(size_t n) { inworld_vector_char_reserve(swig_self(), n); }
inline bool vector_char::empty() const { return inworld_vector_char_empty(swig_self()); }
inline void vector_char::clear() { inworld_vector_char_clear(swig_self()); }
inline void vector_char::push_back(char x) { inworld_vector_char_push_back(swig_self(), x); }
inline char vector_char::get(int i) { return inworld_vector_char_get(swig_self(), i); }
inline void vector_char::set(int i, char arg3) { inworld_vector_char_set(swig_self(), i, arg3); }
inline vector_char memcpy_to_vector_char(const char * data, size_t arg2) {
  auto swig_cres = inworld_memcpy_to_vector_char(data, arg2);
  return vector_char{swig_cres, true};
}
inline vector_float::vector_float() : vector_float{inworld_vector_float_new()} {}
inline vector_float::vector_float(vector_float const & other) : vector_float{inworld_vector_float_copy(other.swig_self())} {}
inline size_t vector_float::size() const { return inworld_vector_float_size(swig_self()); }
inline size_t vector_float::capacity() const { return inworld_vector_float_capacity(swig_self()); }
inline void vector_float::reserve(size_t n) { inworld_vector_float_reserve(swig_self(), n); }
inline bool vector_float::empty() const { return inworld_vector_float_empty(swig_self()); }
inline void vector_float::clear() { inworld_vector_float_clear(swig_self()); }
inline void vector_float::push_back(float x) { inworld_vector_float_push_back(swig_self(), x); }
inline float vector_float::get(int i) { return inworld_vector_float_get(swig_self(), i); }
inline void vector_float::set(int i, float arg3) { inworld_vector_float_set(swig_self(), i, arg3); }
inline vector_float memcpy_to_vector_float(const float * data, size_t arg2) {
  auto swig_cres = inworld_memcpy_to_vector_float(data, arg2);
  return vector_float{swig_cres, true};
}
inline TransformationStreamDestructor::TransformationStreamDestructor(void * context, void * arg2) : TransformationStreamDestructor{inworld_TransformationStreamDestructor_new_pv_pv(context, arg2)} {}
inline TransformationStreamDestructor::TransformationStreamDestructor(TransformationStreamDestructor const & other) : TransformationStreamDestructor{inworld_TransformationStreamDestructor_copy(other.swig_self())} {}
inline StatusOr_InputStream_string TransformationStream_BaseData_To_string::Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_string const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_BaseData_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline StatusOr_InputStream_string TransformationStream_BaseData_To_string::Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_string const & arg2, TransformationStreamThreadedFilterExecutor_BaseData const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_BaseData_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_BaseData_To_string::TransformationStreamThreadedTransformExecutor_BaseData_To_string(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_BaseData_To_string{inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_new_pv_pv(context, arg2)} {}
inline StatusOr_BaseData TransformationStreamThreadedTransformExecutor_BaseData_To_string::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_GetInput(execution_id);
  return StatusOr_BaseData{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_BaseData_To_string::SetOutput(int execution_id, StatusOr_string const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_BaseData_To_string::TransformationStreamThreadedTransformExecutor_BaseData_To_string(TransformationStreamThreadedTransformExecutor_BaseData_To_string const & other) : TransformationStreamThreadedTransformExecutor_BaseData_To_string{inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_string_copy(other.swig_self())} {}
inline StatusOr_InputStream_Content TransformationStream_BaseData_To_Content::Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_Content const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_BaseData_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content TransformationStream_BaseData_To_Content::Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_Content const & arg2, TransformationStreamThreadedFilterExecutor_BaseData const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_BaseData_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_BaseData_To_Content::TransformationStreamThreadedTransformExecutor_BaseData_To_Content(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_BaseData_To_Content{inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_new_pv_pv(context, arg2)} {}
inline StatusOr_BaseData TransformationStreamThreadedTransformExecutor_BaseData_To_Content::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_GetInput(execution_id);
  return StatusOr_BaseData{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_BaseData_To_Content::SetOutput(int execution_id, StatusOr_Content const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_BaseData_To_Content::TransformationStreamThreadedTransformExecutor_BaseData_To_Content(TransformationStreamThreadedTransformExecutor_BaseData_To_Content const & other) : TransformationStreamThreadedTransformExecutor_BaseData_To_Content{inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_Content_copy(other.swig_self())} {}
inline StatusOr_InputStream_AudioChunk TransformationStream_BaseData_To_AudioChunk::Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_BaseData_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline StatusOr_InputStream_AudioChunk TransformationStream_BaseData_To_AudioChunk::Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk const & arg2, TransformationStreamThreadedFilterExecutor_BaseData const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_BaseData_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk::TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk{inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_new_pv_pv(context, arg2)} {}
inline StatusOr_BaseData TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_GetInput(execution_id);
  return StatusOr_BaseData{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk::SetOutput(int execution_id, StatusOr_AudioChunk const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk::TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk(TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk const & other) : TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk{inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_AudioChunk_copy(other.swig_self())} {}
inline StatusOr_InputStream_TTSOutput TransformationStream_BaseData_To_TTSOutput::Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_BaseData_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_TTSOutput{swig_cres, true};
}
inline StatusOr_InputStream_TTSOutput TransformationStream_BaseData_To_TTSOutput::Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput const & arg2, TransformationStreamThreadedFilterExecutor_BaseData const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_BaseData_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_TTSOutput{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput::TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput{inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_new_pv_pv(context, arg2)} {}
inline StatusOr_BaseData TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_GetInput(execution_id);
  return StatusOr_BaseData{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput::SetOutput(int execution_id, StatusOr_TTSOutput const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput::TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput(TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput const & other) : TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput{inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_TTSOutput_copy(other.swig_self())} {}
inline StatusOr_InputStream_BaseData TransformationStream_BaseData_To_BaseData::Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_BaseData_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_BaseData{swig_cres, true};
}
inline StatusOr_InputStream_BaseData TransformationStream_BaseData_To_BaseData::Create(InputStream_BaseData const& input_stream, TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData const & arg2, TransformationStreamThreadedFilterExecutor_BaseData const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_BaseData_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_BaseData{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData::TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData{inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_new_pv_pv(context, arg2)} {}
inline StatusOr_BaseData TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_GetInput(execution_id);
  return StatusOr_BaseData{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData::SetOutput(int execution_id, StatusOr_BaseData const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData::TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData(TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData const & other) : TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData{inworld_TransformationStreamThreadedTransformExecutor_BaseData_To_BaseData_copy(other.swig_self())} {}
inline StatusOr_InputStream_Content TransformationStream_string_To_Content::Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_Content const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_string_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content TransformationStream_string_To_Content::Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_Content const & arg2, TransformationStreamThreadedFilterExecutor_string const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_string_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_string_To_Content::TransformationStreamThreadedTransformExecutor_string_To_Content(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_string_To_Content{inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_new_pv_pv(context, arg2)} {}
inline StatusOr_string TransformationStreamThreadedTransformExecutor_string_To_Content::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_GetInput(execution_id);
  return StatusOr_string{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_string_To_Content::SetOutput(int execution_id, StatusOr_Content const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_string_To_Content::TransformationStreamThreadedTransformExecutor_string_To_Content(TransformationStreamThreadedTransformExecutor_string_To_Content const & other) : TransformationStreamThreadedTransformExecutor_string_To_Content{inworld_TransformationStreamThreadedTransformExecutor_string_To_Content_copy(other.swig_self())} {}
inline StatusOr_InputStream_AudioChunk TransformationStream_string_To_AudioChunk::Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_AudioChunk const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_string_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline StatusOr_InputStream_AudioChunk TransformationStream_string_To_AudioChunk::Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_AudioChunk const & arg2, TransformationStreamThreadedFilterExecutor_string const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_string_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_string_To_AudioChunk::TransformationStreamThreadedTransformExecutor_string_To_AudioChunk(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_string_To_AudioChunk{inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_new_pv_pv(context, arg2)} {}
inline StatusOr_string TransformationStreamThreadedTransformExecutor_string_To_AudioChunk::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_GetInput(execution_id);
  return StatusOr_string{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_string_To_AudioChunk::SetOutput(int execution_id, StatusOr_AudioChunk const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_string_To_AudioChunk::TransformationStreamThreadedTransformExecutor_string_To_AudioChunk(TransformationStreamThreadedTransformExecutor_string_To_AudioChunk const & other) : TransformationStreamThreadedTransformExecutor_string_To_AudioChunk{inworld_TransformationStreamThreadedTransformExecutor_string_To_AudioChunk_copy(other.swig_self())} {}
inline StatusOr_InputStream_TTSOutput TransformationStream_string_To_TTSOutput::Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_TTSOutput const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_string_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_TTSOutput{swig_cres, true};
}
inline StatusOr_InputStream_TTSOutput TransformationStream_string_To_TTSOutput::Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_TTSOutput const & arg2, TransformationStreamThreadedFilterExecutor_string const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_string_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_TTSOutput{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_string_To_TTSOutput::TransformationStreamThreadedTransformExecutor_string_To_TTSOutput(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_string_To_TTSOutput{inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_new_pv_pv(context, arg2)} {}
inline StatusOr_string TransformationStreamThreadedTransformExecutor_string_To_TTSOutput::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_GetInput(execution_id);
  return StatusOr_string{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_string_To_TTSOutput::SetOutput(int execution_id, StatusOr_TTSOutput const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_string_To_TTSOutput::TransformationStreamThreadedTransformExecutor_string_To_TTSOutput(TransformationStreamThreadedTransformExecutor_string_To_TTSOutput const & other) : TransformationStreamThreadedTransformExecutor_string_To_TTSOutput{inworld_TransformationStreamThreadedTransformExecutor_string_To_TTSOutput_copy(other.swig_self())} {}
inline StatusOr_InputStream_BaseData TransformationStream_string_To_BaseData::Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_BaseData const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_string_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_BaseData{swig_cres, true};
}
inline StatusOr_InputStream_BaseData TransformationStream_string_To_BaseData::Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_BaseData const & arg2, TransformationStreamThreadedFilterExecutor_string const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_string_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_BaseData{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_string_To_BaseData::TransformationStreamThreadedTransformExecutor_string_To_BaseData(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_string_To_BaseData{inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_new_pv_pv(context, arg2)} {}
inline StatusOr_string TransformationStreamThreadedTransformExecutor_string_To_BaseData::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_GetInput(execution_id);
  return StatusOr_string{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_string_To_BaseData::SetOutput(int execution_id, StatusOr_BaseData const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_string_To_BaseData::TransformationStreamThreadedTransformExecutor_string_To_BaseData(TransformationStreamThreadedTransformExecutor_string_To_BaseData const & other) : TransformationStreamThreadedTransformExecutor_string_To_BaseData{inworld_TransformationStreamThreadedTransformExecutor_string_To_BaseData_copy(other.swig_self())} {}
inline StatusOr_InputStream_string TransformationStream_string_To_string::Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_string const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_string_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline StatusOr_InputStream_string TransformationStream_string_To_string::Create(InputStream_string const& input_stream, TransformationStreamThreadedTransformExecutor_string_To_string const & arg2, TransformationStreamThreadedFilterExecutor_string const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_string_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_std_string_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_string_To_string::TransformationStreamThreadedTransformExecutor_string_To_string(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_string_To_string{inworld_TransformationStreamThreadedTransformExecutor_string_To_string_new_pv_pv(context, arg2)} {}
inline StatusOr_string TransformationStreamThreadedTransformExecutor_string_To_string::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_string_To_string_GetInput(execution_id);
  return StatusOr_string{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_string_To_string::SetOutput(int execution_id, StatusOr_string const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_string_To_string_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_string_To_string::TransformationStreamThreadedTransformExecutor_string_To_string(TransformationStreamThreadedTransformExecutor_string_To_string const & other) : TransformationStreamThreadedTransformExecutor_string_To_string{inworld_TransformationStreamThreadedTransformExecutor_string_To_string_copy(other.swig_self())} {}
inline StatusOr_InputStream_string TransformationStream_Content_To_string::Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_string const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_Content_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline StatusOr_InputStream_string TransformationStream_Content_To_string::Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_string const & arg2, TransformationStreamThreadedFilterExecutor_Content const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_Content_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_Content_To_string::TransformationStreamThreadedTransformExecutor_Content_To_string(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_Content_To_string{inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_new_pv_pv(context, arg2)} {}
inline StatusOr_Content TransformationStreamThreadedTransformExecutor_Content_To_string::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_GetInput(execution_id);
  return StatusOr_Content{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_Content_To_string::SetOutput(int execution_id, StatusOr_string const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_Content_To_string::TransformationStreamThreadedTransformExecutor_Content_To_string(TransformationStreamThreadedTransformExecutor_Content_To_string const & other) : TransformationStreamThreadedTransformExecutor_Content_To_string{inworld_TransformationStreamThreadedTransformExecutor_Content_To_string_copy(other.swig_self())} {}
inline StatusOr_InputStream_AudioChunk TransformationStream_Content_To_AudioChunk::Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_Content_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline StatusOr_InputStream_AudioChunk TransformationStream_Content_To_AudioChunk::Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk const & arg2, TransformationStreamThreadedFilterExecutor_Content const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_Content_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk::TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk{inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_new_pv_pv(context, arg2)} {}
inline StatusOr_Content TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_GetInput(execution_id);
  return StatusOr_Content{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk::SetOutput(int execution_id, StatusOr_AudioChunk const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk::TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk(TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk const & other) : TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk{inworld_TransformationStreamThreadedTransformExecutor_Content_To_AudioChunk_copy(other.swig_self())} {}
inline StatusOr_InputStream_TTSOutput TransformationStream_Content_To_TTSOutput::Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_Content_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_TTSOutput{swig_cres, true};
}
inline StatusOr_InputStream_TTSOutput TransformationStream_Content_To_TTSOutput::Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput const & arg2, TransformationStreamThreadedFilterExecutor_Content const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_Content_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_TTSOutput{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput::TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput{inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_new_pv_pv(context, arg2)} {}
inline StatusOr_Content TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_GetInput(execution_id);
  return StatusOr_Content{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput::SetOutput(int execution_id, StatusOr_TTSOutput const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput::TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput(TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput const & other) : TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput{inworld_TransformationStreamThreadedTransformExecutor_Content_To_TTSOutput_copy(other.swig_self())} {}
inline StatusOr_InputStream_BaseData TransformationStream_Content_To_BaseData::Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_BaseData const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_Content_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_BaseData{swig_cres, true};
}
inline StatusOr_InputStream_BaseData TransformationStream_Content_To_BaseData::Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_BaseData const & arg2, TransformationStreamThreadedFilterExecutor_Content const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_Content_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_BaseData{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_Content_To_BaseData::TransformationStreamThreadedTransformExecutor_Content_To_BaseData(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_Content_To_BaseData{inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_new_pv_pv(context, arg2)} {}
inline StatusOr_Content TransformationStreamThreadedTransformExecutor_Content_To_BaseData::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_GetInput(execution_id);
  return StatusOr_Content{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_Content_To_BaseData::SetOutput(int execution_id, StatusOr_BaseData const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_Content_To_BaseData::TransformationStreamThreadedTransformExecutor_Content_To_BaseData(TransformationStreamThreadedTransformExecutor_Content_To_BaseData const & other) : TransformationStreamThreadedTransformExecutor_Content_To_BaseData{inworld_TransformationStreamThreadedTransformExecutor_Content_To_BaseData_copy(other.swig_self())} {}
inline StatusOr_InputStream_Content TransformationStream_Content_To_Content::Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_Content const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_Content_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content TransformationStream_Content_To_Content::Create(InputStream_Content const& input_stream, TransformationStreamThreadedTransformExecutor_Content_To_Content const & arg2, TransformationStreamThreadedFilterExecutor_Content const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_Content_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_Content_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_Content_To_Content::TransformationStreamThreadedTransformExecutor_Content_To_Content(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_Content_To_Content{inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_new_pv_pv(context, arg2)} {}
inline StatusOr_Content TransformationStreamThreadedTransformExecutor_Content_To_Content::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_GetInput(execution_id);
  return StatusOr_Content{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_Content_To_Content::SetOutput(int execution_id, StatusOr_Content const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_Content_To_Content::TransformationStreamThreadedTransformExecutor_Content_To_Content(TransformationStreamThreadedTransformExecutor_Content_To_Content const & other) : TransformationStreamThreadedTransformExecutor_Content_To_Content{inworld_TransformationStreamThreadedTransformExecutor_Content_To_Content_copy(other.swig_self())} {}
inline StatusOr_InputStream_string TransformationStream_AudioChunk_To_string::Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_string const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_AudioChunk_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline StatusOr_InputStream_string TransformationStream_AudioChunk_To_string::Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_string const & arg2, TransformationStreamThreadedFilterExecutor_AudioChunk const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_AudioChunk_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_AudioChunk_To_string::TransformationStreamThreadedTransformExecutor_AudioChunk_To_string(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_AudioChunk_To_string{inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_new_pv_pv(context, arg2)} {}
inline StatusOr_AudioChunk TransformationStreamThreadedTransformExecutor_AudioChunk_To_string::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_GetInput(execution_id);
  return StatusOr_AudioChunk{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_AudioChunk_To_string::SetOutput(int execution_id, StatusOr_string const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_AudioChunk_To_string::TransformationStreamThreadedTransformExecutor_AudioChunk_To_string(TransformationStreamThreadedTransformExecutor_AudioChunk_To_string const & other) : TransformationStreamThreadedTransformExecutor_AudioChunk_To_string{inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_string_copy(other.swig_self())} {}
inline StatusOr_InputStream_Content TransformationStream_AudioChunk_To_Content::Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_AudioChunk_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content TransformationStream_AudioChunk_To_Content::Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content const & arg2, TransformationStreamThreadedFilterExecutor_AudioChunk const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_AudioChunk_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content::TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content{inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_new_pv_pv(context, arg2)} {}
inline StatusOr_AudioChunk TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_GetInput(execution_id);
  return StatusOr_AudioChunk{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content::SetOutput(int execution_id, StatusOr_Content const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content::TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content(TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content const & other) : TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content{inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_Content_copy(other.swig_self())} {}
inline StatusOr_InputStream_TTSOutput TransformationStream_AudioChunk_To_TTSOutput::Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_AudioChunk_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_TTSOutput{swig_cres, true};
}
inline StatusOr_InputStream_TTSOutput TransformationStream_AudioChunk_To_TTSOutput::Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput const & arg2, TransformationStreamThreadedFilterExecutor_AudioChunk const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_AudioChunk_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_TTSOutput{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput::TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput{inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_new_pv_pv(context, arg2)} {}
inline StatusOr_AudioChunk TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_GetInput(execution_id);
  return StatusOr_AudioChunk{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput::SetOutput(int execution_id, StatusOr_TTSOutput const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput::TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput(TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput const & other) : TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput{inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_TTSOutput_copy(other.swig_self())} {}
inline StatusOr_InputStream_BaseData TransformationStream_AudioChunk_To_BaseData::Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_AudioChunk_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_BaseData{swig_cres, true};
}
inline StatusOr_InputStream_BaseData TransformationStream_AudioChunk_To_BaseData::Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData const & arg2, TransformationStreamThreadedFilterExecutor_AudioChunk const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_AudioChunk_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_BaseData{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData::TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData{inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_new_pv_pv(context, arg2)} {}
inline StatusOr_AudioChunk TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_GetInput(execution_id);
  return StatusOr_AudioChunk{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData::SetOutput(int execution_id, StatusOr_BaseData const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData::TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData(TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData const & other) : TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData{inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_BaseData_copy(other.swig_self())} {}
inline StatusOr_InputStream_AudioChunk TransformationStream_AudioChunk_To_AudioChunk::Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_AudioChunk_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline StatusOr_InputStream_AudioChunk TransformationStream_AudioChunk_To_AudioChunk::Create(InputStream_AudioChunk const& input_stream, TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk const & arg2, TransformationStreamThreadedFilterExecutor_AudioChunk const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_AudioChunk_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_AudioChunk_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk::TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk{inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_new_pv_pv(context, arg2)} {}
inline StatusOr_AudioChunk TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_GetInput(execution_id);
  return StatusOr_AudioChunk{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk::SetOutput(int execution_id, StatusOr_AudioChunk const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk::TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk(TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk const & other) : TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk{inworld_TransformationStreamThreadedTransformExecutor_AudioChunk_To_AudioChunk_copy(other.swig_self())} {}
inline StatusOr_InputStream_string TransformationStream_TTSOutput_To_string::Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_string const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_TTSOutput_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline StatusOr_InputStream_string TransformationStream_TTSOutput_To_string::Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_string const & arg2, TransformationStreamThreadedFilterExecutor_TTSOutput const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_TTSOutput_To_string_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_std_string_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_TTSOutput_To_string::TransformationStreamThreadedTransformExecutor_TTSOutput_To_string(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_TTSOutput_To_string{inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_new_pv_pv(context, arg2)} {}
inline StatusOr_TTSOutput TransformationStreamThreadedTransformExecutor_TTSOutput_To_string::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_GetInput(execution_id);
  return StatusOr_TTSOutput{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_TTSOutput_To_string::SetOutput(int execution_id, StatusOr_string const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_TTSOutput_To_string::TransformationStreamThreadedTransformExecutor_TTSOutput_To_string(TransformationStreamThreadedTransformExecutor_TTSOutput_To_string const & other) : TransformationStreamThreadedTransformExecutor_TTSOutput_To_string{inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_string_copy(other.swig_self())} {}
inline StatusOr_InputStream_Content TransformationStream_TTSOutput_To_Content::Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_TTSOutput_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content TransformationStream_TTSOutput_To_Content::Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content const & arg2, TransformationStreamThreadedFilterExecutor_TTSOutput const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_TTSOutput_To_Content_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_Content_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content::TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content{inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_new_pv_pv(context, arg2)} {}
inline StatusOr_TTSOutput TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_GetInput(execution_id);
  return StatusOr_TTSOutput{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content::SetOutput(int execution_id, StatusOr_Content const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content::TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content(TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content const & other) : TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content{inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_Content_copy(other.swig_self())} {}
inline StatusOr_InputStream_AudioChunk TransformationStream_TTSOutput_To_AudioChunk::Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_TTSOutput_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline StatusOr_InputStream_AudioChunk TransformationStream_TTSOutput_To_AudioChunk::Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk const & arg2, TransformationStreamThreadedFilterExecutor_TTSOutput const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_TTSOutput_To_AudioChunk_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_AudioChunk_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk::TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk{inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_new_pv_pv(context, arg2)} {}
inline StatusOr_TTSOutput TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_GetInput(execution_id);
  return StatusOr_TTSOutput{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk::SetOutput(int execution_id, StatusOr_AudioChunk const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk::TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk(TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk const & other) : TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk{inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_AudioChunk_copy(other.swig_self())} {}
inline StatusOr_InputStream_BaseData TransformationStream_TTSOutput_To_BaseData::Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_TTSOutput_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_BaseData{swig_cres, true};
}
inline StatusOr_InputStream_BaseData TransformationStream_TTSOutput_To_BaseData::Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData const & arg2, TransformationStreamThreadedFilterExecutor_TTSOutput const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_TTSOutput_To_BaseData_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_BaseData{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData::TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData{inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_new_pv_pv(context, arg2)} {}
inline StatusOr_TTSOutput TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_GetInput(execution_id);
  return StatusOr_TTSOutput{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData::SetOutput(int execution_id, StatusOr_BaseData const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData::TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData(TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData const & other) : TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData{inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_BaseData_copy(other.swig_self())} {}
inline StatusOr_InputStream_TTSOutput TransformationStream_TTSOutput_To_TTSOutput::Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput const & arg2, TransformationStreamDestructor const & arg3) {
  auto swig_cres = inworld_TransformationStream_TTSOutput_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_TTSOutput{swig_cres, true};
}
inline StatusOr_InputStream_TTSOutput TransformationStream_TTSOutput_To_TTSOutput::Create(InputStream_TTSOutput const& input_stream, TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput const & arg2, TransformationStreamThreadedFilterExecutor_TTSOutput const & arg3, TransformationStreamDestructor const & arg4) {
  auto swig_cres = inworld_TransformationStream_TTSOutput_To_TTSOutput_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_swig_helpers_TransformationStreamThreadedTransformExecutor_Sl_inworld_graphs_TTSOutput_Sc_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamThreadedFilterExecutor_Sl_inworld_graphs_TTSOutput_Sg__rcinworld_swig_helpers_TransformationStreamDestructor(input_stream.swig_self(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_TTSOutput{swig_cres, true};
}
inline TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput::TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput(void * context, void * arg2) : TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput{inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_new_pv_pv(context, arg2)} {}
inline StatusOr_TTSOutput TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_GetInput(execution_id);
  return StatusOr_TTSOutput{swig_cres, true};
}
inline void TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput::SetOutput(int execution_id, StatusOr_TTSOutput const& arg2) { inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_SetOutput(execution_id, arg2.swig_self()); }
inline TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput::TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput(TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput const & other) : TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput{inworld_TransformationStreamThreadedTransformExecutor_TTSOutput_To_TTSOutput_copy(other.swig_self())} {}
inline TransformationStreamThreadedFilterExecutor_BaseData::TransformationStreamThreadedFilterExecutor_BaseData(void * context, void * arg2) : TransformationStreamThreadedFilterExecutor_BaseData{inworld_TransformationStreamThreadedFilterExecutor_BaseData_new_pv_pv(context, arg2)} {}
inline StatusOr_BaseData TransformationStreamThreadedFilterExecutor_BaseData::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedFilterExecutor_BaseData_GetInput(execution_id);
  return StatusOr_BaseData{swig_cres, true};
}
inline void TransformationStreamThreadedFilterExecutor_BaseData::SetOutput(int execution_id, bool arg2) { inworld_TransformationStreamThreadedFilterExecutor_BaseData_SetOutput(execution_id, arg2); }
inline TransformationStreamThreadedFilterExecutor_BaseData::TransformationStreamThreadedFilterExecutor_BaseData(TransformationStreamThreadedFilterExecutor_BaseData const & other) : TransformationStreamThreadedFilterExecutor_BaseData{inworld_TransformationStreamThreadedFilterExecutor_BaseData_copy(other.swig_self())} {}
inline TransformationStreamThreadedFilterExecutor_string::TransformationStreamThreadedFilterExecutor_string(void * context, void * arg2) : TransformationStreamThreadedFilterExecutor_string{inworld_TransformationStreamThreadedFilterExecutor_string_new_pv_pv(context, arg2)} {}
inline StatusOr_string TransformationStreamThreadedFilterExecutor_string::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedFilterExecutor_string_GetInput(execution_id);
  return StatusOr_string{swig_cres, true};
}
inline void TransformationStreamThreadedFilterExecutor_string::SetOutput(int execution_id, bool arg2) { inworld_TransformationStreamThreadedFilterExecutor_string_SetOutput(execution_id, arg2); }
inline TransformationStreamThreadedFilterExecutor_string::TransformationStreamThreadedFilterExecutor_string(TransformationStreamThreadedFilterExecutor_string const & other) : TransformationStreamThreadedFilterExecutor_string{inworld_TransformationStreamThreadedFilterExecutor_string_copy(other.swig_self())} {}
inline TransformationStreamThreadedFilterExecutor_Content::TransformationStreamThreadedFilterExecutor_Content(void * context, void * arg2) : TransformationStreamThreadedFilterExecutor_Content{inworld_TransformationStreamThreadedFilterExecutor_Content_new_pv_pv(context, arg2)} {}
inline StatusOr_Content TransformationStreamThreadedFilterExecutor_Content::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedFilterExecutor_Content_GetInput(execution_id);
  return StatusOr_Content{swig_cres, true};
}
inline void TransformationStreamThreadedFilterExecutor_Content::SetOutput(int execution_id, bool arg2) { inworld_TransformationStreamThreadedFilterExecutor_Content_SetOutput(execution_id, arg2); }
inline TransformationStreamThreadedFilterExecutor_Content::TransformationStreamThreadedFilterExecutor_Content(TransformationStreamThreadedFilterExecutor_Content const & other) : TransformationStreamThreadedFilterExecutor_Content{inworld_TransformationStreamThreadedFilterExecutor_Content_copy(other.swig_self())} {}
inline TransformationStreamThreadedFilterExecutor_AudioChunk::TransformationStreamThreadedFilterExecutor_AudioChunk(void * context, void * arg2) : TransformationStreamThreadedFilterExecutor_AudioChunk{inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_new_pv_pv(context, arg2)} {}
inline StatusOr_AudioChunk TransformationStreamThreadedFilterExecutor_AudioChunk::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_GetInput(execution_id);
  return StatusOr_AudioChunk{swig_cres, true};
}
inline void TransformationStreamThreadedFilterExecutor_AudioChunk::SetOutput(int execution_id, bool arg2) { inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_SetOutput(execution_id, arg2); }
inline TransformationStreamThreadedFilterExecutor_AudioChunk::TransformationStreamThreadedFilterExecutor_AudioChunk(TransformationStreamThreadedFilterExecutor_AudioChunk const & other) : TransformationStreamThreadedFilterExecutor_AudioChunk{inworld_TransformationStreamThreadedFilterExecutor_AudioChunk_copy(other.swig_self())} {}
inline TransformationStreamThreadedFilterExecutor_TTSOutput::TransformationStreamThreadedFilterExecutor_TTSOutput(void * context, void * arg2) : TransformationStreamThreadedFilterExecutor_TTSOutput{inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_new_pv_pv(context, arg2)} {}
inline StatusOr_TTSOutput TransformationStreamThreadedFilterExecutor_TTSOutput::GetInput(int execution_id) {
  auto swig_cres = inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_GetInput(execution_id);
  return StatusOr_TTSOutput{swig_cres, true};
}
inline void TransformationStreamThreadedFilterExecutor_TTSOutput::SetOutput(int execution_id, bool arg2) { inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_SetOutput(execution_id, arg2); }
inline TransformationStreamThreadedFilterExecutor_TTSOutput::TransformationStreamThreadedFilterExecutor_TTSOutput(TransformationStreamThreadedFilterExecutor_TTSOutput const & other) : TransformationStreamThreadedFilterExecutor_TTSOutput{inworld_TransformationStreamThreadedFilterExecutor_TTSOutput_copy(other.swig_self())} {}
inline void AgentSpeech::agent_name(std::string const& agent_name) { inworld_AgentSpeech_agent_name_set(swig_self(), (&agent_name)->c_str()); }
inline std::string AgentSpeech::agent_name() const {
  auto swig_cres = inworld_AgentSpeech_agent_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void AgentSpeech::utterance(std::string const& utterance) { inworld_AgentSpeech_utterance_set(swig_self(), (&utterance)->c_str()); }
inline std::string AgentSpeech::utterance() const {
  auto swig_cres = inworld_AgentSpeech_utterance_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline AgentSpeech::AgentSpeech(AgentSpeech const & other) : AgentSpeech{inworld_AgentSpeech_copy(other.swig_self())} {}
inline void AgentAction::agent_name(std::string const& agent_name) { inworld_AgentAction_agent_name_set(swig_self(), (&agent_name)->c_str()); }
inline std::string AgentAction::agent_name() const {
  auto swig_cres = inworld_AgentAction_agent_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void AgentAction::name(std::string const& name) { inworld_AgentAction_name_set(swig_self(), (&name)->c_str()); }
inline std::string AgentAction::name() const {
  auto swig_cres = inworld_AgentAction_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void AgentAction::set_parameter(std::string const& key, std::string const& arg3) { inworld_AgentAction_set_parameter(swig_self(), (&key)->c_str(), (&arg3)->c_str()); }
inline bool AgentAction::contains_parameter(std::string const& key) const { return inworld_AgentAction_contains_parameter(swig_self(), (&key)->c_str()); }
inline std::string AgentAction::get_parameter(std::string const& key) const {
  auto swig_cres = inworld_AgentAction_get_parameter(swig_self(), (&key)->c_str());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline AgentAction::AgentAction(AgentAction const & other) : AgentAction{inworld_AgentAction_copy(other.swig_self())} {}
inline AgentSpeech * Event::speech() {
  auto swig_cres = inworld_Event_speech(swig_self());
  return swig_cres ? new AgentSpeech(swig_cres, false) : nullptr;
}
inline AgentAction * Event::action() {
  auto swig_cres = inworld_Event_action(swig_self());
  return swig_cres ? new AgentAction(swig_cres, false) : nullptr;
}
inline bool Event::is_valid() const { return inworld_Event_is_valid(swig_self()); }
inline Event::Event() : Event{inworld_Event_new()} {}
inline Event::Event(Event const & other) : Event{inworld_Event_copy(other.swig_self())} {}
inline void Intent::name(std::string const& name) { inworld_Intent_name_set(swig_self(), (&name)->c_str()); }
inline std::string Intent::name() const {
  auto swig_cres = inworld_Intent_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Intent::phrases(vector_string * phrases) { inworld_Intent_phrases_set(swig_self(), phrases->swig_self()); }
inline vector_string * Intent::phrases() const {
  auto swig_cres = inworld_Intent_phrases_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline Intent::Intent() : Intent{inworld_Intent_new()} {}
inline Intent::Intent(Intent const & other) : Intent{inworld_Intent_copy(other.swig_self())} {}
inline void CompiledIntent::name(std::string const& name) { inworld_CompiledIntent_name_set(swig_self(), (&name)->c_str()); }
inline std::string CompiledIntent::name() const {
  auto swig_cres = inworld_CompiledIntent_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void CompiledIntent::normalized_phrases(vector_string * normalized_phrases) { inworld_CompiledIntent_normalized_phrases_set(swig_self(), normalized_phrases->swig_self()); }
inline vector_string * CompiledIntent::normalized_phrases() const {
  auto swig_cres = inworld_CompiledIntent_normalized_phrases_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline void CompiledIntent::phrase_embeddings(vector_vector_float * phrase_embeddings) { inworld_CompiledIntent_phrase_embeddings_set(swig_self(), phrase_embeddings->swig_self()); }
inline vector_vector_float * CompiledIntent::phrase_embeddings() const {
  auto swig_cres = inworld_CompiledIntent_phrase_embeddings_get(swig_self());
  return swig_cres ? new vector_vector_float(swig_cres, false) : nullptr;
}
inline CompiledIntent::CompiledIntent() : CompiledIntent{inworld_CompiledIntent_new()} {}
inline CompiledIntent::CompiledIntent(CompiledIntent const & other) : CompiledIntent{inworld_CompiledIntent_copy(other.swig_self())} {}
inline StatusOr_Language::StatusOr_Language() : StatusOr_Language{inworld_StatusOr_Language_new()} {}
inline StatusOr_Language::StatusOr_Language(Language const & value) : StatusOr_Language{inworld_StatusOr_Language_new_rcinworld_library_Language(value.swig_self())} {}
inline StatusOr_Language::StatusOr_Language(Status const & status) : StatusOr_Language{inworld_StatusOr_Language_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_Language::ok() const { return inworld_StatusOr_Language_ok(swig_self()); }
inline Status StatusOr_Language::status() const {
  auto swig_cres = inworld_StatusOr_Language_status(swig_self());
  return Status{swig_cres, false};
}
inline Language StatusOr_Language::value() const {
  auto swig_cres = inworld_StatusOr_Language_value(swig_self());
  return Language{swig_cres, true};
}
inline StatusOr_Language::StatusOr_Language(StatusOr_Language const & other) : StatusOr_Language{inworld_StatusOr_Language_copy(other.swig_self())} {}
inline void Language::lang(std::string const& lang) { inworld_Language_lang_set(swig_self(), (&lang)->c_str()); }
inline std::string Language::lang() const {
  auto swig_cres = inworld_Language_lang_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Language::locale(optional_string * locale) { inworld_Language_locale_set(swig_self(), locale->swig_self()); }
inline optional_string * Language::locale() const {
  auto swig_cres = inworld_Language_locale_get(swig_self());
  return swig_cres ? new optional_string(swig_cres, false) : nullptr;
}
inline StatusOr_Language Language::FromString(std::string const& language_code) {
  auto swig_cres = inworld_Language_FromString((&language_code)->c_str());
  return StatusOr_Language{swig_cres, true};
}
inline std::string Language::ToString() const {
  auto swig_cres = inworld_Language_ToString(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline Language Language::English() {
  auto swig_cres = inworld_Language_English();
  return Language{swig_cres, false};
}
inline Language Language::Chinese() {
  auto swig_cres = inworld_Language_Chinese();
  return Language{swig_cres, false};
}
inline Language Language::Korean() {
  auto swig_cres = inworld_Language_Korean();
  return Language{swig_cres, false};
}
inline Language Language::Japanese() {
  auto swig_cres = inworld_Language_Japanese();
  return Language{swig_cres, false};
}
inline Language Language::Russian() {
  auto swig_cres = inworld_Language_Russian();
  return Language{swig_cres, false};
}
inline Language Language::Spanish() {
  auto swig_cres = inworld_Language_Spanish();
  return Language{swig_cres, false};
}
inline Language Language::French() {
  auto swig_cres = inworld_Language_French();
  return Language{swig_cres, false};
}
inline Language Language::German() {
  auto swig_cres = inworld_Language_German();
  return Language{swig_cres, false};
}
inline Language Language::Italian() {
  auto swig_cres = inworld_Language_Italian();
  return Language{swig_cres, false};
}
inline Language Language::Portuguese() {
  auto swig_cres = inworld_Language_Portuguese();
  return Language{swig_cres, false};
}
inline Language Language::Arabic() {
  auto swig_cres = inworld_Language_Arabic();
  return Language{swig_cres, false};
}
inline Language Language::Hindi() {
  auto swig_cres = inworld_Language_Hindi();
  return Language{swig_cres, false};
}
inline Language Language::Dutch() {
  auto swig_cres = inworld_Language_Dutch();
  return Language{swig_cres, false};
}
inline Language Language::Swedish() {
  auto swig_cres = inworld_Language_Swedish();
  return Language{swig_cres, false};
}
inline Language Language::Norwegian() {
  auto swig_cres = inworld_Language_Norwegian();
  return Language{swig_cres, false};
}
inline Language Language::Danish() {
  auto swig_cres = inworld_Language_Danish();
  return Language{swig_cres, false};
}
inline Language Language::Finnish() {
  auto swig_cres = inworld_Language_Finnish();
  return Language{swig_cres, false};
}
inline Language Language::Polish() {
  auto swig_cres = inworld_Language_Polish();
  return Language{swig_cres, false};
}
inline Language Language::Turkish() {
  auto swig_cres = inworld_Language_Turkish();
  return Language{swig_cres, false};
}
inline Language Language::Thai() {
  auto swig_cres = inworld_Language_Thai();
  return Language{swig_cres, false};
}
inline Language Language::Vietnamese() {
  auto swig_cres = inworld_Language_Vietnamese();
  return Language{swig_cres, false};
}
inline Language Language::Indonesian() {
  auto swig_cres = inworld_Language_Indonesian();
  return Language{swig_cres, false};
}
inline Language Language::Malay() {
  auto swig_cres = inworld_Language_Malay();
  return Language{swig_cres, false};
}
inline Language Language::Hebrew() {
  auto swig_cres = inworld_Language_Hebrew();
  return Language{swig_cres, false};
}
inline Language Language::Ukrainian() {
  auto swig_cres = inworld_Language_Ukrainian();
  return Language{swig_cres, false};
}
inline Language::Language() : Language{inworld_Language_new()} {}
inline Language::Language(Language const & other) : Language{inworld_Language_copy(other.swig_self())} {}
inline std::string DeviceInfo::name() const {
  auto swig_cres = inworld_DeviceInfo_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline unsigned long long DeviceInfo::free_memory_bytes() const { return inworld_DeviceInfo_free_memory_bytes_get(swig_self()); }
inline unsigned long long DeviceInfo::total_memory_bytes() const { return inworld_DeviceInfo_total_memory_bytes_get(swig_self()); }
inline DeviceInfo::DeviceInfo() : DeviceInfo{inworld_DeviceInfo_new()} {}
inline DeviceInfo::DeviceInfo(DeviceInfo const & other) : DeviceInfo{inworld_DeviceInfo_copy(other.swig_self())} {}
inline DeviceType Device::type() const {
  auto swig_cres = inworld_Device_type(swig_self());
  return (DeviceType)swig_cres;
}
inline signed char Device::index() const { return inworld_Device_index(swig_self()); }
inline DeviceInfo Device::info() const {
  auto swig_cres = inworld_Device_info(swig_self());
  return DeviceInfo{swig_cres, true};
}
inline std::string DeviceTypeToString(DeviceType type) {
  auto swig_cres = inworld_DeviceTypeToString((inworld_DeviceType)type);
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline DeviceRegistry DeviceRegistry::GetInstance() {
  auto swig_cres = inworld_DeviceRegistry_GetInstance();
  return DeviceRegistry{swig_cres, false};
}
inline vector_Device DeviceRegistry::GetAvailableDevices() const {
  auto swig_cres = inworld_DeviceRegistry_GetAvailableDevices(swig_self());
  return vector_Device{swig_cres, true};
}
inline void ModelProperties::model_id(std::string const& model_id) { inworld_ModelProperties_model_id_set(swig_self(), (&model_id)->c_str()); }
inline std::string ModelProperties::model_id() const {
  auto swig_cres = inworld_ModelProperties_model_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline ModelProperties::ModelProperties() : ModelProperties{inworld_ModelProperties_new()} {}
inline ModelProperties::ModelProperties(ModelProperties const & other) : ModelProperties{inworld_ModelProperties_copy(other.swig_self())} {}
inline ModelProperties ModelInterface::model_properties() const {
  auto swig_cres = inworld_ModelInterface_model_properties(swig_self());
  return ModelProperties{swig_cres, true};
}
inline bool ModelInterface::is_valid() const { return inworld_ModelInterface_is_valid(swig_self()); }
inline StatusOr_vector_float TextEmbedderInterface::Embed(std::string const& text) const {
  auto swig_cres = inworld_TextEmbedderInterface_Embed(swig_self(), (&text)->c_str());
  return StatusOr_vector_float{swig_cres, true};
}
inline StatusOr_vector_vector_float TextEmbedderInterface::EmbedBatch(vector_string const & texts) const {
  auto swig_cres = inworld_TextEmbedderInterface_EmbedBatch(swig_self(), texts.swig_self());
  return StatusOr_vector_vector_float{swig_cres, true};
}
inline bool TextEmbedderInterface::is_valid() const { return inworld_TextEmbedderInterface_is_valid(swig_self()); }
inline optional_LocalTextEmbedderConfig::optional_LocalTextEmbedderConfig() : optional_LocalTextEmbedderConfig{inworld_optional_LocalTextEmbedderConfig_new()} {}
inline optional_LocalTextEmbedderConfig::optional_LocalTextEmbedderConfig(LocalTextEmbedderConfig const & value) : optional_LocalTextEmbedderConfig{inworld_optional_LocalTextEmbedderConfig_new_rcinworld_LocalTextEmbedderConfig(value.swig_self())} {}
inline optional_LocalTextEmbedderConfig::optional_LocalTextEmbedderConfig(optional_LocalTextEmbedderConfig const & other) : optional_LocalTextEmbedderConfig{inworld_optional_LocalTextEmbedderConfig_copy(other.swig_self())} {}
inline bool optional_LocalTextEmbedderConfig::has_value() const { return inworld_optional_LocalTextEmbedderConfig_has_value(swig_self()); }
inline LocalTextEmbedderConfig optional_LocalTextEmbedderConfig::value() {
  auto swig_cres = inworld_optional_LocalTextEmbedderConfig_value(swig_self());
  return LocalTextEmbedderConfig{swig_cres, false};
}
inline LocalTextEmbedderConfig optional_LocalTextEmbedderConfig::value() const {
  auto swig_cres = inworld_optional_LocalTextEmbedderConfig_valueConst(swig_self());
  return LocalTextEmbedderConfig{swig_cres, false};
}
inline LocalTextEmbedderConfig optional_LocalTextEmbedderConfig::value_or(LocalTextEmbedderConfig const & default_value) const {
  auto swig_cres = inworld_optional_LocalTextEmbedderConfig_value_or(swig_self(), default_value.swig_self());
  return LocalTextEmbedderConfig{swig_cres, true};
}
inline void optional_LocalTextEmbedderConfig::reset() { inworld_optional_LocalTextEmbedderConfig_reset(swig_self()); }
inline LocalTextEmbedderConfig optional_LocalTextEmbedderConfig::operator *() {
  auto swig_cres = inworld_optional_LocalTextEmbedderConfig_get(swig_self());
  return LocalTextEmbedderConfig{swig_cres, false};
}
inline LocalTextEmbedderConfig optional_LocalTextEmbedderConfig::operator *() const {
  auto swig_cres = inworld_optional_LocalTextEmbedderConfig_getConst(swig_self());
  return LocalTextEmbedderConfig{swig_cres, false};
}
inline LocalTextEmbedderConfig optional_LocalTextEmbedderConfig::get_value() {
  auto swig_cres = inworld_optional_LocalTextEmbedderConfig_get_value(swig_self());
  return LocalTextEmbedderConfig{swig_cres, false};
}
inline void optional_LocalTextEmbedderConfig::set_value(LocalTextEmbedderConfig & t) { inworld_optional_LocalTextEmbedderConfig_set_value(swig_self(), t.swig_self()); }
inline optional_RemoteTextEmbedderConfig::optional_RemoteTextEmbedderConfig() : optional_RemoteTextEmbedderConfig{inworld_optional_RemoteTextEmbedderConfig_new()} {}
inline optional_RemoteTextEmbedderConfig::optional_RemoteTextEmbedderConfig(RemoteTextEmbedderConfig const & value) : optional_RemoteTextEmbedderConfig{inworld_optional_RemoteTextEmbedderConfig_new_rcinworld_RemoteTextEmbedderConfig(value.swig_self())} {}
inline optional_RemoteTextEmbedderConfig::optional_RemoteTextEmbedderConfig(optional_RemoteTextEmbedderConfig const & other) : optional_RemoteTextEmbedderConfig{inworld_optional_RemoteTextEmbedderConfig_copy(other.swig_self())} {}
inline bool optional_RemoteTextEmbedderConfig::has_value() const { return inworld_optional_RemoteTextEmbedderConfig_has_value(swig_self()); }
inline RemoteTextEmbedderConfig optional_RemoteTextEmbedderConfig::value() {
  auto swig_cres = inworld_optional_RemoteTextEmbedderConfig_value(swig_self());
  return RemoteTextEmbedderConfig{swig_cres, false};
}
inline RemoteTextEmbedderConfig optional_RemoteTextEmbedderConfig::value() const {
  auto swig_cres = inworld_optional_RemoteTextEmbedderConfig_valueConst(swig_self());
  return RemoteTextEmbedderConfig{swig_cres, false};
}
inline RemoteTextEmbedderConfig optional_RemoteTextEmbedderConfig::value_or(RemoteTextEmbedderConfig const & default_value) const {
  auto swig_cres = inworld_optional_RemoteTextEmbedderConfig_value_or(swig_self(), default_value.swig_self());
  return RemoteTextEmbedderConfig{swig_cres, true};
}
inline void optional_RemoteTextEmbedderConfig::reset() { inworld_optional_RemoteTextEmbedderConfig_reset(swig_self()); }
inline RemoteTextEmbedderConfig optional_RemoteTextEmbedderConfig::operator *() {
  auto swig_cres = inworld_optional_RemoteTextEmbedderConfig_get(swig_self());
  return RemoteTextEmbedderConfig{swig_cres, false};
}
inline RemoteTextEmbedderConfig optional_RemoteTextEmbedderConfig::operator *() const {
  auto swig_cres = inworld_optional_RemoteTextEmbedderConfig_getConst(swig_self());
  return RemoteTextEmbedderConfig{swig_cres, false};
}
inline RemoteTextEmbedderConfig optional_RemoteTextEmbedderConfig::get_value() {
  auto swig_cres = inworld_optional_RemoteTextEmbedderConfig_get_value(swig_self());
  return RemoteTextEmbedderConfig{swig_cres, false};
}
inline void optional_RemoteTextEmbedderConfig::set_value(RemoteTextEmbedderConfig & t) { inworld_optional_RemoteTextEmbedderConfig_set_value(swig_self(), t.swig_self()); }
inline void LocalTextEmbedderConfig::model_path(std::string const& model_path) { inworld_LocalTextEmbedderConfig_model_path_set(swig_self(), (&model_path)->c_str()); }
inline std::string LocalTextEmbedderConfig::model_path() const {
  auto swig_cres = inworld_LocalTextEmbedderConfig_model_path_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LocalTextEmbedderConfig::device(Device * device) { inworld_LocalTextEmbedderConfig_device_set(swig_self(), device->swig_self()); }
inline Device * LocalTextEmbedderConfig::device() const {
  auto swig_cres = inworld_LocalTextEmbedderConfig_device_get(swig_self());
  return swig_cres ? new Device(swig_cres, false) : nullptr;
}
inline LocalTextEmbedderConfig::LocalTextEmbedderConfig() : LocalTextEmbedderConfig{inworld_LocalTextEmbedderConfig_new()} {}
inline LocalTextEmbedderConfig::LocalTextEmbedderConfig(LocalTextEmbedderConfig const & other) : LocalTextEmbedderConfig{inworld_LocalTextEmbedderConfig_copy(other.swig_self())} {}
inline void RemoteTextEmbedderConfig::provider(std::string const& provider) { inworld_RemoteTextEmbedderConfig_provider_set(swig_self(), (&provider)->c_str()); }
inline std::string RemoteTextEmbedderConfig::provider() const {
  auto swig_cres = inworld_RemoteTextEmbedderConfig_provider_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RemoteTextEmbedderConfig::model_name(std::string const& model_name) { inworld_RemoteTextEmbedderConfig_model_name_set(swig_self(), (&model_name)->c_str()); }
inline std::string RemoteTextEmbedderConfig::model_name() const {
  auto swig_cres = inworld_RemoteTextEmbedderConfig_model_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RemoteTextEmbedderConfig::api_key(std::string const& api_key) { inworld_RemoteTextEmbedderConfig_api_key_set(swig_self(), (&api_key)->c_str()); }
inline std::string RemoteTextEmbedderConfig::api_key() const {
  auto swig_cres = inworld_RemoteTextEmbedderConfig_api_key_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline RemoteTextEmbedderConfig::RemoteTextEmbedderConfig() : RemoteTextEmbedderConfig{inworld_RemoteTextEmbedderConfig_new()} {}
inline RemoteTextEmbedderConfig::RemoteTextEmbedderConfig(RemoteTextEmbedderConfig const & other) : RemoteTextEmbedderConfig{inworld_RemoteTextEmbedderConfig_copy(other.swig_self())} {}
inline bool TextEmbedderCreationConfig::has_local_config() const { return inworld_TextEmbedderCreationConfig_has_local_config(swig_self()); }
inline bool TextEmbedderCreationConfig::has_remote_config() const { return inworld_TextEmbedderCreationConfig_has_remote_config(swig_self()); }
inline optional_LocalTextEmbedderConfig TextEmbedderCreationConfig::get_local_config() const {
  auto swig_cres = inworld_TextEmbedderCreationConfig_get_local_config(swig_self());
  return optional_LocalTextEmbedderConfig{swig_cres, true};
}
inline optional_RemoteTextEmbedderConfig TextEmbedderCreationConfig::get_remote_config() const {
  auto swig_cres = inworld_TextEmbedderCreationConfig_get_remote_config(swig_self());
  return optional_RemoteTextEmbedderConfig{swig_cres, true};
}
inline void TextEmbedderCreationConfig::set_local_config(LocalTextEmbedderConfig const & config) { inworld_TextEmbedderCreationConfig_set_local_config(swig_self(), config.swig_self()); }
inline void TextEmbedderCreationConfig::set_remote_config(RemoteTextEmbedderConfig const & config) { inworld_TextEmbedderCreationConfig_set_remote_config(swig_self(), config.swig_self()); }
inline TextEmbedderCreationConfig::TextEmbedderCreationConfig() : TextEmbedderCreationConfig{inworld_TextEmbedderCreationConfig_new()} {}
inline TextEmbedderCreationConfig::TextEmbedderCreationConfig(TextEmbedderCreationConfig const & other) : TextEmbedderCreationConfig{inworld_TextEmbedderCreationConfig_copy(other.swig_self())} {}
inline StatusOr_TextEmbedderInterface TextEmbedderFactory::CreateTextEmbedder(TextEmbedderCreationConfig const & config) const {
  auto swig_cres = inworld_TextEmbedderFactory_CreateTextEmbedder(swig_self(), config.swig_self());
  return StatusOr_TextEmbedderInterface{swig_cres, true};
}
inline TextEmbedderFactory::TextEmbedderFactory() : TextEmbedderFactory{inworld_TextEmbedderFactory_new()} {}
inline TextEmbedderFactory::TextEmbedderFactory(TextEmbedderFactory const & other) : TextEmbedderFactory{inworld_TextEmbedderFactory_copy(other.swig_self())} {}
inline StatusOr_string RenderJinja(std::string const& jinja_template, std::string const& arg2) {
  auto swig_cres = inworld_RenderJinja((&jinja_template)->c_str(), (&arg2)->c_str());
  return StatusOr_string{swig_cres, true};
}
inline optional_float::optional_float() : optional_float{inworld_optional_float_new()} {}
inline optional_float::optional_float(float value) : optional_float{inworld_optional_float_new_rcf(value)} {}
inline optional_float::optional_float(optional_float const & other) : optional_float{inworld_optional_float_copy(other.swig_self())} {}
inline bool optional_float::has_value() const { return inworld_optional_float_has_value(swig_self()); }
inline float * optional_float::value() { return inworld_optional_float_value(swig_self()); }
inline float optional_float::value() const { return inworld_optional_float_valueConst(swig_self()); }
inline float optional_float::value_or(float default_value) const { return inworld_optional_float_value_or(swig_self(), default_value); }
inline void optional_float::reset() { inworld_optional_float_reset(swig_self()); }
inline float * optional_float::operator *() { return inworld_optional_float_get(swig_self()); }
inline float optional_float::operator *() const { return inworld_optional_float_getConst(swig_self()); }
inline float * optional_float::get_value() { return inworld_optional_float_get_value(swig_self()); }
inline void optional_float::set_value(float * t) { inworld_optional_float_set_value(swig_self(), t); }
inline optional_int::optional_int() : optional_int{inworld_optional_int_new()} {}
inline optional_int::optional_int(int value) : optional_int{inworld_optional_int_new_rci(value)} {}
inline optional_int::optional_int(optional_int const & other) : optional_int{inworld_optional_int_copy(other.swig_self())} {}
inline bool optional_int::has_value() const { return inworld_optional_int_has_value(swig_self()); }
inline int * optional_int::value() { return inworld_optional_int_value(swig_self()); }
inline int optional_int::value() const { return inworld_optional_int_valueConst(swig_self()); }
inline int optional_int::value_or(int default_value) const { return inworld_optional_int_value_or(swig_self(), default_value); }
inline void optional_int::reset() { inworld_optional_int_reset(swig_self()); }
inline int * optional_int::operator *() { return inworld_optional_int_get(swig_self()); }
inline int optional_int::operator *() const { return inworld_optional_int_getConst(swig_self()); }
inline int * optional_int::get_value() { return inworld_optional_int_get_value(swig_self()); }
inline void optional_int::set_value(int * t) { inworld_optional_int_set_value(swig_self(), t); }
inline optional_sizet::optional_sizet() : optional_sizet{inworld_optional_sizet_new()} {}
inline optional_sizet::optional_sizet(size_t value) : optional_sizet{inworld_optional_sizet_new_rcsize_t(value)} {}
inline optional_sizet::optional_sizet(optional_sizet const & other) : optional_sizet{inworld_optional_sizet_copy(other.swig_self())} {}
inline bool optional_sizet::has_value() const { return inworld_optional_sizet_has_value(swig_self()); }
inline size_t * optional_sizet::value() { return inworld_optional_sizet_value(swig_self()); }
inline size_t optional_sizet::value() const { return inworld_optional_sizet_valueConst(swig_self()); }
inline size_t optional_sizet::value_or(size_t default_value) const { return inworld_optional_sizet_value_or(swig_self(), default_value); }
inline void optional_sizet::reset() { inworld_optional_sizet_reset(swig_self()); }
inline size_t * optional_sizet::operator *() { return inworld_optional_sizet_get(swig_self()); }
inline size_t optional_sizet::operator *() const { return inworld_optional_sizet_getConst(swig_self()); }
inline size_t * optional_sizet::get_value() { return inworld_optional_sizet_get_value(swig_self()); }
inline void optional_sizet::set_value(size_t * t) { inworld_optional_sizet_set_value(swig_self(), t); }
inline optional_string::optional_string() : optional_string{inworld_optional_string_new()} {}
inline optional_string::optional_string(std::string const& value) : optional_string{inworld_optional_string_new_rcstd_string((&value)->c_str())} {}
inline optional_string::optional_string(optional_string const & other) : optional_string{inworld_optional_string_copy(other.swig_self())} {}
inline bool optional_string::has_value() const { return inworld_optional_string_has_value(swig_self()); }
inline char * optional_string::value() { return inworld_optional_string_value(swig_self()); }
inline std::string optional_string::value() const {
  auto swig_cres = inworld_optional_string_valueConst(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline std::string optional_string::value_or(std::string const& default_value) const {
  auto swig_cres = inworld_optional_string_value_or(swig_self(), (&default_value)->c_str());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void optional_string::reset() { inworld_optional_string_reset(swig_self()); }
inline char * optional_string::operator *() { return inworld_optional_string_get(swig_self()); }
inline std::string optional_string::operator *() const {
  auto swig_cres = inworld_optional_string_getConst(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline char * optional_string::get_value() { return inworld_optional_string_get_value(swig_self()); }
inline void optional_string::set_value(char * t) { inworld_optional_string_set_value(swig_self(), t); }
inline optional_UserContext::optional_UserContext() : optional_UserContext{inworld_optional_UserContext_new()} {}
inline optional_UserContext::optional_UserContext(UserContext const & value) : optional_UserContext{inworld_optional_UserContext_new_rcinworld_graphs_UserContext(value.swig_self())} {}
inline optional_UserContext::optional_UserContext(optional_UserContext const & other) : optional_UserContext{inworld_optional_UserContext_copy(other.swig_self())} {}
inline bool optional_UserContext::has_value() const { return inworld_optional_UserContext_has_value(swig_self()); }
inline UserContext optional_UserContext::value() {
  auto swig_cres = inworld_optional_UserContext_value(swig_self());
  return UserContext{swig_cres, false};
}
inline UserContext optional_UserContext::value() const {
  auto swig_cres = inworld_optional_UserContext_valueConst(swig_self());
  return UserContext{swig_cres, false};
}
inline UserContext optional_UserContext::value_or(UserContext const & default_value) const {
  auto swig_cres = inworld_optional_UserContext_value_or(swig_self(), default_value.swig_self());
  return UserContext{swig_cres, true};
}
inline void optional_UserContext::reset() { inworld_optional_UserContext_reset(swig_self()); }
inline UserContext optional_UserContext::operator *() {
  auto swig_cres = inworld_optional_UserContext_get(swig_self());
  return UserContext{swig_cres, false};
}
inline UserContext optional_UserContext::operator *() const {
  auto swig_cres = inworld_optional_UserContext_getConst(swig_self());
  return UserContext{swig_cres, false};
}
inline UserContext optional_UserContext::get_value() {
  auto swig_cres = inworld_optional_UserContext_get_value(swig_self());
  return UserContext{swig_cres, false};
}
inline void optional_UserContext::set_value(UserContext & t) { inworld_optional_UserContext_set_value(swig_self(), t.swig_self()); }
inline void AudioChunk::data(vector_float * data) { inworld_AudioChunk_data_set(swig_self(), data->swig_self()); }
inline vector_float * AudioChunk::data() const {
  auto swig_cres = inworld_AudioChunk_data_get(swig_self());
  return swig_cres ? new vector_float(swig_cres, false) : nullptr;
}
inline void AudioChunk::sample_rate(int sample_rate) { inworld_AudioChunk_sample_rate_set(swig_self(), sample_rate); }
inline int AudioChunk::sample_rate() const { return inworld_AudioChunk_sample_rate_get(swig_self()); }
inline AudioChunk::AudioChunk() : AudioChunk{inworld_AudioChunk_new()} {}
inline AudioChunk::AudioChunk(AudioChunk const & other) : AudioChunk{inworld_AudioChunk_copy(other.swig_self())} {}
inline Duration::Duration() : Duration{inworld_Duration_new()} {}
inline Duration::Duration(Duration const & other) : Duration{inworld_Duration_copy(other.swig_self())} {}
inline Duration Nanoseconds(int Nanoseconds) {
  auto swig_cres = inworld_Nanoseconds(Nanoseconds);
  return Duration{swig_cres, true};
}
inline Duration Milliseconds(int Milliseconds) {
  auto swig_cres = inworld_Milliseconds(Milliseconds);
  return Duration{swig_cres, true};
}
inline Duration Seconds(int Seconds) {
  auto swig_cres = inworld_Seconds(Seconds);
  return Duration{swig_cres, true};
}
inline Duration Minutes(int Minutes) {
  auto swig_cres = inworld_Minutes(Minutes);
  return Duration{swig_cres, true};
}
inline void SpeechSynthesisPostprocessingConfig::sample_rate(int sample_rate) { inworld_SpeechSynthesisPostprocessingConfig_sample_rate_set(swig_self(), sample_rate); }
inline int SpeechSynthesisPostprocessingConfig::sample_rate() const { return inworld_SpeechSynthesisPostprocessingConfig_sample_rate_get(swig_self()); }
inline SpeechSynthesisPostprocessingConfig::SpeechSynthesisPostprocessingConfig() : SpeechSynthesisPostprocessingConfig{inworld_SpeechSynthesisPostprocessingConfig_new()} {}
inline SpeechSynthesisPostprocessingConfig::SpeechSynthesisPostprocessingConfig(SpeechSynthesisPostprocessingConfig const & other) : SpeechSynthesisPostprocessingConfig{inworld_SpeechSynthesisPostprocessingConfig_copy(other.swig_self())} {}
inline void SpeechSynthesisInferenceConfig::temperature(float temperature) { inworld_SpeechSynthesisInferenceConfig_temperature_set(swig_self(), temperature); }
inline float SpeechSynthesisInferenceConfig::temperature() const { return inworld_SpeechSynthesisInferenceConfig_temperature_get(swig_self()); }
inline void SpeechSynthesisInferenceConfig::speaking_rate(float speaking_rate) { inworld_SpeechSynthesisInferenceConfig_speaking_rate_set(swig_self(), speaking_rate); }
inline float SpeechSynthesisInferenceConfig::speaking_rate() const { return inworld_SpeechSynthesisInferenceConfig_speaking_rate_get(swig_self()); }
inline SpeechSynthesisInferenceConfig::SpeechSynthesisInferenceConfig() : SpeechSynthesisInferenceConfig{inworld_SpeechSynthesisInferenceConfig_new()} {}
inline SpeechSynthesisInferenceConfig::SpeechSynthesisInferenceConfig(SpeechSynthesisInferenceConfig const & other) : SpeechSynthesisInferenceConfig{inworld_SpeechSynthesisInferenceConfig_copy(other.swig_self())} {}
inline void InworldSpeechSynthesisConfig::model_id(std::string const& model_id) { inworld_InworldSpeechSynthesisConfig_model_id_set(swig_self(), (&model_id)->c_str()); }
inline std::string InworldSpeechSynthesisConfig::model_id() const {
  auto swig_cres = inworld_InworldSpeechSynthesisConfig_model_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void InworldSpeechSynthesisConfig::postprocessing(SpeechSynthesisPostprocessingConfig * postprocessing) { inworld_InworldSpeechSynthesisConfig_postprocessing_set(swig_self(), postprocessing->swig_self()); }
inline SpeechSynthesisPostprocessingConfig * InworldSpeechSynthesisConfig::postprocessing() const {
  auto swig_cres = inworld_InworldSpeechSynthesisConfig_postprocessing_get(swig_self());
  return swig_cres ? new SpeechSynthesisPostprocessingConfig(swig_cres, false) : nullptr;
}
inline void InworldSpeechSynthesisConfig::inference(SpeechSynthesisInferenceConfig * inference) { inworld_InworldSpeechSynthesisConfig_inference_set(swig_self(), inference->swig_self()); }
inline SpeechSynthesisInferenceConfig * InworldSpeechSynthesisConfig::inference() const {
  auto swig_cres = inworld_InworldSpeechSynthesisConfig_inference_get(swig_self());
  return swig_cres ? new SpeechSynthesisInferenceConfig(swig_cres, false) : nullptr;
}
inline InworldSpeechSynthesisConfig::InworldSpeechSynthesisConfig() : InworldSpeechSynthesisConfig{inworld_InworldSpeechSynthesisConfig_new()} {}
inline InworldSpeechSynthesisConfig::InworldSpeechSynthesisConfig(InworldSpeechSynthesisConfig const & other) : InworldSpeechSynthesisConfig{inworld_InworldSpeechSynthesisConfig_copy(other.swig_self())} {}
inline void ElevenLabsSpeechSynthesisConfig::query_params(QueryParams * query_params) { inworld_ElevenLabsSpeechSynthesisConfig_query_params_set(swig_self(), query_params->swig_self()); }
inline QueryParams * ElevenLabsSpeechSynthesisConfig::query_params() const {
  auto swig_cres = inworld_ElevenLabsSpeechSynthesisConfig_query_params_get(swig_self());
  return swig_cres ? new QueryParams(swig_cres, false) : nullptr;
}
inline void ElevenLabsSpeechSynthesisConfig::request_params(RequestParams * request_params) { inworld_ElevenLabsSpeechSynthesisConfig_request_params_set(swig_self(), request_params->swig_self()); }
inline RequestParams * ElevenLabsSpeechSynthesisConfig::request_params() const {
  auto swig_cres = inworld_ElevenLabsSpeechSynthesisConfig_request_params_get(swig_self());
  return swig_cres ? new RequestParams(swig_cres, false) : nullptr;
}
inline ElevenLabsSpeechSynthesisConfig::ElevenLabsSpeechSynthesisConfig() : ElevenLabsSpeechSynthesisConfig{inworld_ElevenLabsSpeechSynthesisConfig_new()} {}
inline ElevenLabsSpeechSynthesisConfig::ElevenLabsSpeechSynthesisConfig(ElevenLabsSpeechSynthesisConfig const & other) : ElevenLabsSpeechSynthesisConfig{inworld_ElevenLabsSpeechSynthesisConfig_copy(other.swig_self())} {}
inline void QueryParams::enable_logging(bool enable_logging) { inworld_QueryParams_enable_logging_set(swig_self(), enable_logging); }
inline bool QueryParams::enable_logging() const { return inworld_QueryParams_enable_logging_get(swig_self()); }
inline void QueryParams::output_format(QueryParams::OutputFormat output_format) { inworld_QueryParams_output_format_set(swig_self(), (inworld_QueryParams_OutputFormat)output_format); }
inline QueryParams::OutputFormat QueryParams::output_format() const {
  auto swig_cres = inworld_QueryParams_output_format_get(swig_self());
  return (QueryParams::OutputFormat)swig_cres;
}
inline QueryParams::QueryParams() : QueryParams{inworld_QueryParams_new()} {}
inline QueryParams::QueryParams(QueryParams const & other) : QueryParams{inworld_QueryParams_copy(other.swig_self())} {}
inline void RequestParams::model_id(std::string const& model_id) { inworld_RequestParams_model_id_set(swig_self(), (&model_id)->c_str()); }
inline std::string RequestParams::model_id() const {
  auto swig_cres = inworld_RequestParams_model_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RequestParams::apply_text_normalization(RequestParams::TextNormalization apply_text_normalization) { inworld_RequestParams_apply_text_normalization_set(swig_self(), (inworld_RequestParams_TextNormalization)apply_text_normalization); }
inline RequestParams::TextNormalization RequestParams::apply_text_normalization() const {
  auto swig_cres = inworld_RequestParams_apply_text_normalization_get(swig_self());
  return (RequestParams::TextNormalization)swig_cres;
}
inline RequestParams::RequestParams() : RequestParams{inworld_RequestParams_new()} {}
inline RequestParams::RequestParams(RequestParams const & other) : RequestParams{inworld_RequestParams_copy(other.swig_self())} {}
inline InworldSpeechSynthesisConfig * SpeechSynthesisConfig::inworld_config() {
  auto swig_cres = inworld_SpeechSynthesisConfig_inworld_config(swig_self());
  return swig_cres ? new InworldSpeechSynthesisConfig(swig_cres, false) : nullptr;
}
inline ElevenLabsSpeechSynthesisConfig * SpeechSynthesisConfig::eleven_labs_config() {
  auto swig_cres = inworld_SpeechSynthesisConfig_eleven_labs_config(swig_self());
  return swig_cres ? new ElevenLabsSpeechSynthesisConfig(swig_cres, false) : nullptr;
}
inline SpeechSynthesisConfig::SpeechSynthesisConfig() : SpeechSynthesisConfig{inworld_SpeechSynthesisConfig_new()} {}
inline SpeechSynthesisConfig::SpeechSynthesisConfig(SpeechSynthesisConfig const & other) : SpeechSynthesisConfig{inworld_SpeechSynthesisConfig_copy(other.swig_self())} {}
inline void Voice::id(std::string const& id) { inworld_Voice_id_set(swig_self(), (&id)->c_str()); }
inline std::string Voice::id() const {
  auto swig_cres = inworld_Voice_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Voice::language(optional_Language * language) { inworld_Voice_language_set(swig_self(), language->swig_self()); }
inline optional_Language * Voice::language() const {
  auto swig_cres = inworld_Voice_language_get(swig_self());
  return swig_cres ? new optional_Language(swig_cres, false) : nullptr;
}
inline Voice::Voice() : Voice{inworld_Voice_new()} {}
inline Voice::Voice(Voice const & other) : Voice{inworld_Voice_copy(other.swig_self())} {}
inline bool TTSInterface::is_valid() const { return inworld_TTSInterface_is_valid(swig_self()); }
inline StatusOr_InputStream_AudioChunk TTSInterface::SynthesizeSpeech(Voice const & voice, std::string const& arg3) const {
  auto swig_cres = inworld_TTSInterface_SynthesizeSpeech_rcinworld_Voice_rcstd_string(swig_self(), voice.swig_self(), (&arg3)->c_str());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline StatusOr_InputStream_AudioChunk TTSInterface::SynthesizeSpeech(Voice const & voice, std::string const& arg3, SpeechSynthesisConfig const & arg4) const {
  auto swig_cres = inworld_TTSInterface_SynthesizeSpeech_rcinworld_Voice_rcstd_string_rcinworld_SpeechSynthesisConfig(swig_self(), voice.swig_self(), (&arg3)->c_str(), arg4.swig_self());
  return StatusOr_InputStream_AudioChunk{swig_cres, true};
}
inline optional_Voice::optional_Voice() : optional_Voice{inworld_optional_Voice_new()} {}
inline optional_Voice::optional_Voice(Voice const & value) : optional_Voice{inworld_optional_Voice_new_rcinworld_Voice(value.swig_self())} {}
inline optional_Voice::optional_Voice(optional_Voice const & other) : optional_Voice{inworld_optional_Voice_copy(other.swig_self())} {}
inline bool optional_Voice::has_value() const { return inworld_optional_Voice_has_value(swig_self()); }
inline Voice optional_Voice::value() {
  auto swig_cres = inworld_optional_Voice_value(swig_self());
  return Voice{swig_cres, false};
}
inline Voice optional_Voice::value() const {
  auto swig_cres = inworld_optional_Voice_valueConst(swig_self());
  return Voice{swig_cres, false};
}
inline Voice optional_Voice::value_or(Voice const & default_value) const {
  auto swig_cres = inworld_optional_Voice_value_or(swig_self(), default_value.swig_self());
  return Voice{swig_cres, true};
}
inline void optional_Voice::reset() { inworld_optional_Voice_reset(swig_self()); }
inline Voice optional_Voice::operator *() {
  auto swig_cres = inworld_optional_Voice_get(swig_self());
  return Voice{swig_cres, false};
}
inline Voice optional_Voice::operator *() const {
  auto swig_cres = inworld_optional_Voice_getConst(swig_self());
  return Voice{swig_cres, false};
}
inline Voice optional_Voice::get_value() {
  auto swig_cres = inworld_optional_Voice_get_value(swig_self());
  return Voice{swig_cres, false};
}
inline void optional_Voice::set_value(Voice & t) { inworld_optional_Voice_set_value(swig_self(), t.swig_self()); }
inline optional_TextGenerationConfig::optional_TextGenerationConfig() : optional_TextGenerationConfig{inworld_optional_TextGenerationConfig_new()} {}
inline optional_TextGenerationConfig::optional_TextGenerationConfig(TextGenerationConfig const & value) : optional_TextGenerationConfig{inworld_optional_TextGenerationConfig_new_rcinworld_TextGenerationConfig(value.swig_self())} {}
inline optional_TextGenerationConfig::optional_TextGenerationConfig(optional_TextGenerationConfig const & other) : optional_TextGenerationConfig{inworld_optional_TextGenerationConfig_copy(other.swig_self())} {}
inline bool optional_TextGenerationConfig::has_value() const { return inworld_optional_TextGenerationConfig_has_value(swig_self()); }
inline TextGenerationConfig optional_TextGenerationConfig::value() {
  auto swig_cres = inworld_optional_TextGenerationConfig_value(swig_self());
  return TextGenerationConfig{swig_cres, false};
}
inline TextGenerationConfig optional_TextGenerationConfig::value() const {
  auto swig_cres = inworld_optional_TextGenerationConfig_valueConst(swig_self());
  return TextGenerationConfig{swig_cres, false};
}
inline TextGenerationConfig optional_TextGenerationConfig::value_or(TextGenerationConfig const & default_value) const {
  auto swig_cres = inworld_optional_TextGenerationConfig_value_or(swig_self(), default_value.swig_self());
  return TextGenerationConfig{swig_cres, true};
}
inline void optional_TextGenerationConfig::reset() { inworld_optional_TextGenerationConfig_reset(swig_self()); }
inline TextGenerationConfig optional_TextGenerationConfig::operator *() {
  auto swig_cres = inworld_optional_TextGenerationConfig_get(swig_self());
  return TextGenerationConfig{swig_cres, false};
}
inline TextGenerationConfig optional_TextGenerationConfig::operator *() const {
  auto swig_cres = inworld_optional_TextGenerationConfig_getConst(swig_self());
  return TextGenerationConfig{swig_cres, false};
}
inline TextGenerationConfig optional_TextGenerationConfig::get_value() {
  auto swig_cres = inworld_optional_TextGenerationConfig_get_value(swig_self());
  return TextGenerationConfig{swig_cres, false};
}
inline void optional_TextGenerationConfig::set_value(TextGenerationConfig & t) { inworld_optional_TextGenerationConfig_set_value(swig_self(), t.swig_self()); }
inline optional_ToolChoice::optional_ToolChoice() : optional_ToolChoice{inworld_optional_ToolChoice_new()} {}
inline optional_ToolChoice::optional_ToolChoice(ToolChoice const & value) : optional_ToolChoice{inworld_optional_ToolChoice_new_rcinworld_ToolChoice(value.swig_self())} {}
inline optional_ToolChoice::optional_ToolChoice(optional_ToolChoice const & other) : optional_ToolChoice{inworld_optional_ToolChoice_copy(other.swig_self())} {}
inline bool optional_ToolChoice::has_value() const { return inworld_optional_ToolChoice_has_value(swig_self()); }
inline ToolChoice optional_ToolChoice::value() {
  auto swig_cres = inworld_optional_ToolChoice_value(swig_self());
  return ToolChoice{swig_cres, false};
}
inline ToolChoice optional_ToolChoice::value() const {
  auto swig_cres = inworld_optional_ToolChoice_valueConst(swig_self());
  return ToolChoice{swig_cres, false};
}
inline ToolChoice optional_ToolChoice::value_or(ToolChoice const & default_value) const {
  auto swig_cres = inworld_optional_ToolChoice_value_or(swig_self(), default_value.swig_self());
  return ToolChoice{swig_cres, true};
}
inline void optional_ToolChoice::reset() { inworld_optional_ToolChoice_reset(swig_self()); }
inline ToolChoice optional_ToolChoice::operator *() {
  auto swig_cres = inworld_optional_ToolChoice_get(swig_self());
  return ToolChoice{swig_cres, false};
}
inline ToolChoice optional_ToolChoice::operator *() const {
  auto swig_cres = inworld_optional_ToolChoice_getConst(swig_self());
  return ToolChoice{swig_cres, false};
}
inline ToolChoice optional_ToolChoice::get_value() {
  auto swig_cres = inworld_optional_ToolChoice_get_value(swig_self());
  return ToolChoice{swig_cres, false};
}
inline void optional_ToolChoice::set_value(ToolChoice & t) { inworld_optional_ToolChoice_set_value(swig_self(), t.swig_self()); }
inline Vector_ChatMessage::Vector_ChatMessage() : Vector_ChatMessage{inworld_Vector_ChatMessage_new()} {}
inline Vector_ChatMessage::Vector_ChatMessage(Vector_ChatMessage const & other) : Vector_ChatMessage{inworld_Vector_ChatMessage_copy(other.swig_self())} {}
inline size_t Vector_ChatMessage::size() const { return inworld_Vector_ChatMessage_size(swig_self()); }
inline size_t Vector_ChatMessage::capacity() const { return inworld_Vector_ChatMessage_capacity(swig_self()); }
inline void Vector_ChatMessage::reserve(size_t n) { inworld_Vector_ChatMessage_reserve(swig_self(), n); }
inline bool Vector_ChatMessage::empty() const { return inworld_Vector_ChatMessage_empty(swig_self()); }
inline void Vector_ChatMessage::clear() { inworld_Vector_ChatMessage_clear(swig_self()); }
inline void Vector_ChatMessage::push_back(ChatMessage const & x) { inworld_Vector_ChatMessage_push_back(swig_self(), x.swig_self()); }
inline ChatMessage Vector_ChatMessage::get(int i) {
  auto swig_cres = inworld_Vector_ChatMessage_get(swig_self(), i);
  return ChatMessage{swig_cres, false};
}
inline void Vector_ChatMessage::set(int i, ChatMessage const & arg3) { inworld_Vector_ChatMessage_set(swig_self(), i, arg3.swig_self()); }
inline Vector_Tool::Vector_Tool() : Vector_Tool{inworld_Vector_Tool_new()} {}
inline Vector_Tool::Vector_Tool(Vector_Tool const & other) : Vector_Tool{inworld_Vector_Tool_copy(other.swig_self())} {}
inline size_t Vector_Tool::size() const { return inworld_Vector_Tool_size(swig_self()); }
inline size_t Vector_Tool::capacity() const { return inworld_Vector_Tool_capacity(swig_self()); }
inline void Vector_Tool::reserve(size_t n) { inworld_Vector_Tool_reserve(swig_self(), n); }
inline bool Vector_Tool::empty() const { return inworld_Vector_Tool_empty(swig_self()); }
inline void Vector_Tool::clear() { inworld_Vector_Tool_clear(swig_self()); }
inline void Vector_Tool::push_back(Tool const & x) { inworld_Vector_Tool_push_back(swig_self(), x.swig_self()); }
inline Tool Vector_Tool::get(int i) {
  auto swig_cres = inworld_Vector_Tool_get(swig_self(), i);
  return Tool{swig_cres, false};
}
inline void Vector_Tool::set(int i, Tool const & arg3) { inworld_Vector_Tool_set(swig_self(), i, arg3.swig_self()); }
inline optional_vector_ChatMessage::optional_vector_ChatMessage() : optional_vector_ChatMessage{inworld_optional_vector_ChatMessage_new()} {}
inline optional_vector_ChatMessage::optional_vector_ChatMessage(Vector_ChatMessage const & value) : optional_vector_ChatMessage{inworld_optional_vector_ChatMessage_new_rcstd_vector_Sl_inworld_graphs_ChatMessage_Sg_(value.swig_self())} {}
inline optional_vector_ChatMessage::optional_vector_ChatMessage(optional_vector_ChatMessage const & other) : optional_vector_ChatMessage{inworld_optional_vector_ChatMessage_copy(other.swig_self())} {}
inline bool optional_vector_ChatMessage::has_value() const { return inworld_optional_vector_ChatMessage_has_value(swig_self()); }
inline Vector_ChatMessage optional_vector_ChatMessage::value() {
  auto swig_cres = inworld_optional_vector_ChatMessage_value(swig_self());
  return Vector_ChatMessage{swig_cres, false};
}
inline Vector_ChatMessage optional_vector_ChatMessage::value() const {
  auto swig_cres = inworld_optional_vector_ChatMessage_valueConst(swig_self());
  return Vector_ChatMessage{swig_cres, false};
}
inline Vector_ChatMessage optional_vector_ChatMessage::value_or(Vector_ChatMessage const & default_value) const {
  auto swig_cres = inworld_optional_vector_ChatMessage_value_or(swig_self(), default_value.swig_self());
  return Vector_ChatMessage{swig_cres, true};
}
inline void optional_vector_ChatMessage::reset() { inworld_optional_vector_ChatMessage_reset(swig_self()); }
inline Vector_ChatMessage optional_vector_ChatMessage::operator *() {
  auto swig_cres = inworld_optional_vector_ChatMessage_get(swig_self());
  return Vector_ChatMessage{swig_cres, false};
}
inline Vector_ChatMessage optional_vector_ChatMessage::operator *() const {
  auto swig_cres = inworld_optional_vector_ChatMessage_getConst(swig_self());
  return Vector_ChatMessage{swig_cres, false};
}
inline Vector_ChatMessage optional_vector_ChatMessage::get_value() {
  auto swig_cres = inworld_optional_vector_ChatMessage_get_value(swig_self());
  return Vector_ChatMessage{swig_cres, false};
}
inline void optional_vector_ChatMessage::set_value(Vector_ChatMessage & t) { inworld_optional_vector_ChatMessage_set_value(swig_self(), t.swig_self()); }
inline optional_vector_Tool::optional_vector_Tool() : optional_vector_Tool{inworld_optional_vector_Tool_new()} {}
inline optional_vector_Tool::optional_vector_Tool(Vector_Tool const & value) : optional_vector_Tool{inworld_optional_vector_Tool_new_rcstd_vector_Sl_inworld_Tool_Sg_(value.swig_self())} {}
inline optional_vector_Tool::optional_vector_Tool(optional_vector_Tool const & other) : optional_vector_Tool{inworld_optional_vector_Tool_copy(other.swig_self())} {}
inline bool optional_vector_Tool::has_value() const { return inworld_optional_vector_Tool_has_value(swig_self()); }
inline Vector_Tool optional_vector_Tool::value() {
  auto swig_cres = inworld_optional_vector_Tool_value(swig_self());
  return Vector_Tool{swig_cres, false};
}
inline Vector_Tool optional_vector_Tool::value() const {
  auto swig_cres = inworld_optional_vector_Tool_valueConst(swig_self());
  return Vector_Tool{swig_cres, false};
}
inline Vector_Tool optional_vector_Tool::value_or(Vector_Tool const & default_value) const {
  auto swig_cres = inworld_optional_vector_Tool_value_or(swig_self(), default_value.swig_self());
  return Vector_Tool{swig_cres, true};
}
inline void optional_vector_Tool::reset() { inworld_optional_vector_Tool_reset(swig_self()); }
inline Vector_Tool optional_vector_Tool::operator *() {
  auto swig_cres = inworld_optional_vector_Tool_get(swig_self());
  return Vector_Tool{swig_cres, false};
}
inline Vector_Tool optional_vector_Tool::operator *() const {
  auto swig_cres = inworld_optional_vector_Tool_getConst(swig_self());
  return Vector_Tool{swig_cres, false};
}
inline Vector_Tool optional_vector_Tool::get_value() {
  auto swig_cres = inworld_optional_vector_Tool_get_value(swig_self());
  return Vector_Tool{swig_cres, false};
}
inline void optional_vector_Tool::set_value(Vector_Tool & t) { inworld_optional_vector_Tool_set_value(swig_self(), t.swig_self()); }
inline void SpeechRecognitionConfig::language(optional_Language * language) { inworld_SpeechRecognitionConfig_language_set(swig_self(), language->swig_self()); }
inline optional_Language * SpeechRecognitionConfig::language() const {
  auto swig_cres = inworld_SpeechRecognitionConfig_language_get(swig_self());
  return swig_cres ? new optional_Language(swig_cres, false) : nullptr;
}
inline SpeechRecognitionConfig::SpeechRecognitionConfig() : SpeechRecognitionConfig{inworld_SpeechRecognitionConfig_new()} {}
inline SpeechRecognitionConfig::SpeechRecognitionConfig(SpeechRecognitionConfig const & other) : SpeechRecognitionConfig{inworld_SpeechRecognitionConfig_copy(other.swig_self())} {}
inline bool STTInterface::is_valid() const { return inworld_STTInterface_is_valid(swig_self()); }
inline StatusOr_InputStream_string STTInterface::RecognizeSpeech(AudioChunk & audio_chunk, SpeechRecognitionConfig const & arg3) const {
  auto swig_cres = inworld_STTInterface_RecognizeSpeech(swig_self(), audio_chunk.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_string{swig_cres, true};
}
inline optional_SpeechSynthesisConfig::optional_SpeechSynthesisConfig() : optional_SpeechSynthesisConfig{inworld_optional_SpeechSynthesisConfig_new()} {}
inline optional_SpeechSynthesisConfig::optional_SpeechSynthesisConfig(SpeechSynthesisConfig const & value) : optional_SpeechSynthesisConfig{inworld_optional_SpeechSynthesisConfig_new_rcinworld_SpeechSynthesisConfig(value.swig_self())} {}
inline optional_SpeechSynthesisConfig::optional_SpeechSynthesisConfig(optional_SpeechSynthesisConfig const & other) : optional_SpeechSynthesisConfig{inworld_optional_SpeechSynthesisConfig_copy(other.swig_self())} {}
inline bool optional_SpeechSynthesisConfig::has_value() const { return inworld_optional_SpeechSynthesisConfig_has_value(swig_self()); }
inline SpeechSynthesisConfig optional_SpeechSynthesisConfig::value() {
  auto swig_cres = inworld_optional_SpeechSynthesisConfig_value(swig_self());
  return SpeechSynthesisConfig{swig_cres, false};
}
inline SpeechSynthesisConfig optional_SpeechSynthesisConfig::value() const {
  auto swig_cres = inworld_optional_SpeechSynthesisConfig_valueConst(swig_self());
  return SpeechSynthesisConfig{swig_cres, false};
}
inline SpeechSynthesisConfig optional_SpeechSynthesisConfig::value_or(SpeechSynthesisConfig const & default_value) const {
  auto swig_cres = inworld_optional_SpeechSynthesisConfig_value_or(swig_self(), default_value.swig_self());
  return SpeechSynthesisConfig{swig_cres, true};
}
inline void optional_SpeechSynthesisConfig::reset() { inworld_optional_SpeechSynthesisConfig_reset(swig_self()); }
inline SpeechSynthesisConfig optional_SpeechSynthesisConfig::operator *() {
  auto swig_cres = inworld_optional_SpeechSynthesisConfig_get(swig_self());
  return SpeechSynthesisConfig{swig_cres, false};
}
inline SpeechSynthesisConfig optional_SpeechSynthesisConfig::operator *() const {
  auto swig_cres = inworld_optional_SpeechSynthesisConfig_getConst(swig_self());
  return SpeechSynthesisConfig{swig_cres, false};
}
inline SpeechSynthesisConfig optional_SpeechSynthesisConfig::get_value() {
  auto swig_cres = inworld_optional_SpeechSynthesisConfig_get_value(swig_self());
  return SpeechSynthesisConfig{swig_cres, false};
}
inline void optional_SpeechSynthesisConfig::set_value(SpeechSynthesisConfig & t) { inworld_optional_SpeechSynthesisConfig_set_value(swig_self(), t.swig_self()); }
inline optional_SpeechRecognitionConfig::optional_SpeechRecognitionConfig() : optional_SpeechRecognitionConfig{inworld_optional_SpeechRecognitionConfig_new()} {}
inline optional_SpeechRecognitionConfig::optional_SpeechRecognitionConfig(SpeechRecognitionConfig const & value) : optional_SpeechRecognitionConfig{inworld_optional_SpeechRecognitionConfig_new_rcinworld_SpeechRecognitionConfig(value.swig_self())} {}
inline optional_SpeechRecognitionConfig::optional_SpeechRecognitionConfig(optional_SpeechRecognitionConfig const & other) : optional_SpeechRecognitionConfig{inworld_optional_SpeechRecognitionConfig_copy(other.swig_self())} {}
inline bool optional_SpeechRecognitionConfig::has_value() const { return inworld_optional_SpeechRecognitionConfig_has_value(swig_self()); }
inline SpeechRecognitionConfig optional_SpeechRecognitionConfig::value() {
  auto swig_cres = inworld_optional_SpeechRecognitionConfig_value(swig_self());
  return SpeechRecognitionConfig{swig_cres, false};
}
inline SpeechRecognitionConfig optional_SpeechRecognitionConfig::value() const {
  auto swig_cres = inworld_optional_SpeechRecognitionConfig_valueConst(swig_self());
  return SpeechRecognitionConfig{swig_cres, false};
}
inline SpeechRecognitionConfig optional_SpeechRecognitionConfig::value_or(SpeechRecognitionConfig const & default_value) const {
  auto swig_cres = inworld_optional_SpeechRecognitionConfig_value_or(swig_self(), default_value.swig_self());
  return SpeechRecognitionConfig{swig_cres, true};
}
inline void optional_SpeechRecognitionConfig::reset() { inworld_optional_SpeechRecognitionConfig_reset(swig_self()); }
inline SpeechRecognitionConfig optional_SpeechRecognitionConfig::operator *() {
  auto swig_cres = inworld_optional_SpeechRecognitionConfig_get(swig_self());
  return SpeechRecognitionConfig{swig_cres, false};
}
inline SpeechRecognitionConfig optional_SpeechRecognitionConfig::operator *() const {
  auto swig_cres = inworld_optional_SpeechRecognitionConfig_getConst(swig_self());
  return SpeechRecognitionConfig{swig_cres, false};
}
inline SpeechRecognitionConfig optional_SpeechRecognitionConfig::get_value() {
  auto swig_cres = inworld_optional_SpeechRecognitionConfig_get_value(swig_self());
  return SpeechRecognitionConfig{swig_cres, false};
}
inline void optional_SpeechRecognitionConfig::set_value(SpeechRecognitionConfig & t) { inworld_optional_SpeechRecognitionConfig_set_value(swig_self(), t.swig_self()); }
inline optional_TextClassifierConfig::optional_TextClassifierConfig() : optional_TextClassifierConfig{inworld_optional_TextClassifierConfig_new()} {}
inline optional_TextClassifierConfig::optional_TextClassifierConfig(TextClassifierConfig const & value) : optional_TextClassifierConfig{inworld_optional_TextClassifierConfig_new_rcinworld_TextClassifierConfig(value.swig_self())} {}
inline optional_TextClassifierConfig::optional_TextClassifierConfig(optional_TextClassifierConfig const & other) : optional_TextClassifierConfig{inworld_optional_TextClassifierConfig_copy(other.swig_self())} {}
inline bool optional_TextClassifierConfig::has_value() const { return inworld_optional_TextClassifierConfig_has_value(swig_self()); }
inline TextClassifierConfig optional_TextClassifierConfig::value() {
  auto swig_cres = inworld_optional_TextClassifierConfig_value(swig_self());
  return TextClassifierConfig{swig_cres, false};
}
inline TextClassifierConfig optional_TextClassifierConfig::value() const {
  auto swig_cres = inworld_optional_TextClassifierConfig_valueConst(swig_self());
  return TextClassifierConfig{swig_cres, false};
}
inline TextClassifierConfig optional_TextClassifierConfig::value_or(TextClassifierConfig const & default_value) const {
  auto swig_cres = inworld_optional_TextClassifierConfig_value_or(swig_self(), default_value.swig_self());
  return TextClassifierConfig{swig_cres, true};
}
inline void optional_TextClassifierConfig::reset() { inworld_optional_TextClassifierConfig_reset(swig_self()); }
inline TextClassifierConfig optional_TextClassifierConfig::operator *() {
  auto swig_cres = inworld_optional_TextClassifierConfig_get(swig_self());
  return TextClassifierConfig{swig_cres, false};
}
inline TextClassifierConfig optional_TextClassifierConfig::operator *() const {
  auto swig_cres = inworld_optional_TextClassifierConfig_getConst(swig_self());
  return TextClassifierConfig{swig_cres, false};
}
inline TextClassifierConfig optional_TextClassifierConfig::get_value() {
  auto swig_cres = inworld_optional_TextClassifierConfig_get_value(swig_self());
  return TextClassifierConfig{swig_cres, false};
}
inline void optional_TextClassifierConfig::set_value(TextClassifierConfig & t) { inworld_optional_TextClassifierConfig_set_value(swig_self(), t.swig_self()); }
inline LogitBiasVector::LogitBiasVector() : LogitBiasVector{inworld_LogitBiasVector_new()} {}
inline LogitBiasVector::LogitBiasVector(LogitBiasVector const & other) : LogitBiasVector{inworld_LogitBiasVector_copy(other.swig_self())} {}
inline size_t LogitBiasVector::size() const { return inworld_LogitBiasVector_size(swig_self()); }
inline size_t LogitBiasVector::capacity() const { return inworld_LogitBiasVector_capacity(swig_self()); }
inline void LogitBiasVector::reserve(size_t n) { inworld_LogitBiasVector_reserve(swig_self(), n); }
inline bool LogitBiasVector::empty() const { return inworld_LogitBiasVector_empty(swig_self()); }
inline void LogitBiasVector::clear() { inworld_LogitBiasVector_clear(swig_self()); }
inline void LogitBiasVector::push_back(LogitBias const & x) { inworld_LogitBiasVector_push_back(swig_self(), x.swig_self()); }
inline LogitBias LogitBiasVector::get(int i) {
  auto swig_cres = inworld_LogitBiasVector_get(swig_self(), i);
  return LogitBias{swig_cres, false};
}
inline void LogitBiasVector::set(int i, LogitBias const & arg3) { inworld_LogitBiasVector_set(swig_self(), i, arg3.swig_self()); }
inline StatusOr_Tools::StatusOr_Tools() : StatusOr_Tools{inworld_StatusOr_Tools_new()} {}
inline StatusOr_Tools::StatusOr_Tools(Vector_Tool const & value) : StatusOr_Tools{inworld_StatusOr_Tools_new_rcstd_vector_Sl_inworld_Tool_Sg_(value.swig_self())} {}
inline StatusOr_Tools::StatusOr_Tools(Status const & status) : StatusOr_Tools{inworld_StatusOr_Tools_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_Tools::ok() const { return inworld_StatusOr_Tools_ok(swig_self()); }
inline Status StatusOr_Tools::status() const {
  auto swig_cres = inworld_StatusOr_Tools_status(swig_self());
  return Status{swig_cres, false};
}
inline Vector_Tool StatusOr_Tools::value() const {
  auto swig_cres = inworld_StatusOr_Tools_value(swig_self());
  return Vector_Tool{swig_cres, true};
}
inline StatusOr_Tools::StatusOr_Tools(StatusOr_Tools const & other) : StatusOr_Tools{inworld_StatusOr_Tools_copy(other.swig_self())} {}
inline Messages::Messages() : Messages{inworld_Messages_new()} {}
inline Messages::Messages(Messages const & other) : Messages{inworld_Messages_copy(other.swig_self())} {}
inline size_t Messages::size() const { return inworld_Messages_size(swig_self()); }
inline size_t Messages::capacity() const { return inworld_Messages_capacity(swig_self()); }
inline void Messages::reserve(size_t n) { inworld_Messages_reserve(swig_self(), n); }
inline bool Messages::empty() const { return inworld_Messages_empty(swig_self()); }
inline void Messages::clear() { inworld_Messages_clear(swig_self()); }
inline void Messages::push_back(Message const & x) { inworld_Messages_push_back(swig_self(), x.swig_self()); }
inline Message Messages::get(int i) {
  auto swig_cres = inworld_Messages_get(swig_self(), i);
  return Message{swig_cres, false};
}
inline void Messages::set(int i, Message const & arg3) { inworld_Messages_set(swig_self(), i, arg3.swig_self()); }
inline ToolCalls::ToolCalls() : ToolCalls{inworld_ToolCalls_new()} {}
inline ToolCalls::ToolCalls(ToolCalls const & other) : ToolCalls{inworld_ToolCalls_copy(other.swig_self())} {}
inline size_t ToolCalls::size() const { return inworld_ToolCalls_size(swig_self()); }
inline size_t ToolCalls::capacity() const { return inworld_ToolCalls_capacity(swig_self()); }
inline void ToolCalls::reserve(size_t n) { inworld_ToolCalls_reserve(swig_self(), n); }
inline bool ToolCalls::empty() const { return inworld_ToolCalls_empty(swig_self()); }
inline void ToolCalls::clear() { inworld_ToolCalls_clear(swig_self()); }
inline void ToolCalls::push_back(ToolCall const & x) { inworld_ToolCalls_push_back(swig_self(), x.swig_self()); }
inline ToolCall ToolCalls::get(int i) {
  auto swig_cres = inworld_ToolCalls_get(swig_self(), i);
  return ToolCall{swig_cres, false};
}
inline void ToolCalls::set(int i, ToolCall const & arg3) { inworld_ToolCalls_set(swig_self(), i, arg3.swig_self()); }
inline ContentItems::ContentItems() : ContentItems{inworld_ContentItems_new()} {}
inline ContentItems::ContentItems(ContentItems const & other) : ContentItems{inworld_ContentItems_copy(other.swig_self())} {}
inline size_t ContentItems::size() const { return inworld_ContentItems_size(swig_self()); }
inline size_t ContentItems::capacity() const { return inworld_ContentItems_capacity(swig_self()); }
inline void ContentItems::reserve(size_t n) { inworld_ContentItems_reserve(swig_self(), n); }
inline bool ContentItems::empty() const { return inworld_ContentItems_empty(swig_self()); }
inline void ContentItems::clear() { inworld_ContentItems_clear(swig_self()); }
inline void ContentItems::push_back(ContentItem const & x) { inworld_ContentItems_push_back(swig_self(), x.swig_self()); }
inline ContentItem ContentItems::get(int i) {
  auto swig_cres = inworld_ContentItems_get(swig_self(), i);
  return ContentItem{swig_cres, false};
}
inline void ContentItems::set(int i, ContentItem const & arg3) { inworld_ContentItems_set(swig_self(), i, arg3.swig_self()); }
inline void LogitBias::token_id(std::string const& token_id) { inworld_LogitBias_token_id_set(swig_self(), (&token_id)->c_str()); }
inline std::string LogitBias::token_id() const {
  auto swig_cres = inworld_LogitBias_token_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LogitBias::bias_value(int bias_value) { inworld_LogitBias_bias_value_set(swig_self(), bias_value); }
inline int LogitBias::bias_value() const { return inworld_LogitBias_bias_value_get(swig_self()); }
inline LogitBias::LogitBias() : LogitBias{inworld_LogitBias_new()} {}
inline LogitBias::LogitBias(LogitBias const & other) : LogitBias{inworld_LogitBias_copy(other.swig_self())} {}
inline void TextGenerationConfig::max_new_tokens(int max_new_tokens) { inworld_TextGenerationConfig_max_new_tokens_set(swig_self(), max_new_tokens); }
inline int TextGenerationConfig::max_new_tokens() const { return inworld_TextGenerationConfig_max_new_tokens_get(swig_self()); }
inline void TextGenerationConfig::max_prompt_length(int max_prompt_length) { inworld_TextGenerationConfig_max_prompt_length_set(swig_self(), max_prompt_length); }
inline int TextGenerationConfig::max_prompt_length() const { return inworld_TextGenerationConfig_max_prompt_length_get(swig_self()); }
inline void TextGenerationConfig::temperature(float temperature) { inworld_TextGenerationConfig_temperature_set(swig_self(), temperature); }
inline float TextGenerationConfig::temperature() const { return inworld_TextGenerationConfig_temperature_get(swig_self()); }
inline void TextGenerationConfig::top_p(float top_p) { inworld_TextGenerationConfig_top_p_set(swig_self(), top_p); }
inline float TextGenerationConfig::top_p() const { return inworld_TextGenerationConfig_top_p_get(swig_self()); }
inline void TextGenerationConfig::repetition_penalty(float repetition_penalty) { inworld_TextGenerationConfig_repetition_penalty_set(swig_self(), repetition_penalty); }
inline float TextGenerationConfig::repetition_penalty() const { return inworld_TextGenerationConfig_repetition_penalty_get(swig_self()); }
inline void TextGenerationConfig::frequency_penalty(float frequency_penalty) { inworld_TextGenerationConfig_frequency_penalty_set(swig_self(), frequency_penalty); }
inline float TextGenerationConfig::frequency_penalty() const { return inworld_TextGenerationConfig_frequency_penalty_get(swig_self()); }
inline void TextGenerationConfig::presence_penalty(float presence_penalty) { inworld_TextGenerationConfig_presence_penalty_set(swig_self(), presence_penalty); }
inline float TextGenerationConfig::presence_penalty() const { return inworld_TextGenerationConfig_presence_penalty_get(swig_self()); }
inline void TextGenerationConfig::stop_sequences(vector_string * stop_sequences) { inworld_TextGenerationConfig_stop_sequences_set(swig_self(), stop_sequences->swig_self()); }
inline vector_string * TextGenerationConfig::stop_sequences() const {
  auto swig_cres = inworld_TextGenerationConfig_stop_sequences_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline void TextGenerationConfig::seed(optional_int * seed) { inworld_TextGenerationConfig_seed_set(swig_self(), seed->swig_self()); }
inline optional_int * TextGenerationConfig::seed() const {
  auto swig_cres = inworld_TextGenerationConfig_seed_get(swig_self());
  return swig_cres ? new optional_int(swig_cres, false) : nullptr;
}
inline void TextGenerationConfig::logit_bias(LogitBiasVector * logit_bias) { inworld_TextGenerationConfig_logit_bias_set(swig_self(), logit_bias->swig_self()); }
inline LogitBiasVector * TextGenerationConfig::logit_bias() const {
  auto swig_cres = inworld_TextGenerationConfig_logit_bias_get(swig_self());
  return swig_cres ? new LogitBiasVector(swig_cres, false) : nullptr;
}
inline bool TextGenerationConfig::HasSeed() const { return inworld_TextGenerationConfig_HasSeed(swig_self()); }
inline int TextGenerationConfig::GetSeed() const { return inworld_TextGenerationConfig_GetSeed(swig_self()); }
inline void TextGenerationConfig::SetSeed(int seed_value) { inworld_TextGenerationConfig_SetSeed(swig_self(), seed_value); }
inline void TextGenerationConfig::ClearSeed() { inworld_TextGenerationConfig_ClearSeed(swig_self()); }
inline TextGenerationConfig::TextGenerationConfig() : TextGenerationConfig{inworld_TextGenerationConfig_new()} {}
inline TextGenerationConfig::TextGenerationConfig(TextGenerationConfig const & other) : TextGenerationConfig{inworld_TextGenerationConfig_copy(other.swig_self())} {}
inline void Tool::name(std::string const& name) { inworld_Tool_name_set(swig_self(), (&name)->c_str()); }
inline std::string Tool::name() const {
  auto swig_cres = inworld_Tool_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Tool::description(std::string const& description) { inworld_Tool_description_set(swig_self(), (&description)->c_str()); }
inline std::string Tool::description() const {
  auto swig_cres = inworld_Tool_description_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Tool::SetPropertiesFromString(std::string const& json_str) { inworld_Tool_SetPropertiesFromString(swig_self(), (&json_str)->c_str()); }
inline std::string Tool::GetPropertiesAsString() const {
  auto swig_cres = inworld_Tool_GetPropertiesAsString(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline Tool::Tool() : Tool{inworld_Tool_new()} {}
inline Tool::Tool(Tool const & other) : Tool{inworld_Tool_copy(other.swig_self())} {}
inline void FunctionChoice::type(std::string const& type) { inworld_FunctionChoice_type_set(swig_self(), (&type)->c_str()); }
inline std::string FunctionChoice::type() const {
  auto swig_cres = inworld_FunctionChoice_type_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void FunctionChoice::name(std::string const& name) { inworld_FunctionChoice_name_set(swig_self(), (&name)->c_str()); }
inline std::string FunctionChoice::name() const {
  auto swig_cres = inworld_FunctionChoice_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline FunctionChoice::FunctionChoice() : FunctionChoice{inworld_FunctionChoice_new()} {}
inline FunctionChoice::FunctionChoice(FunctionChoice const & other) : FunctionChoice{inworld_FunctionChoice_copy(other.swig_self())} {}
inline bool ToolChoice::IsStringChoice() const { return inworld_ToolChoice_IsStringChoice(swig_self()); }
inline bool ToolChoice::IsFunctionChoice() const { return inworld_ToolChoice_IsFunctionChoice(swig_self()); }
inline std::string ToolChoice::GetStringChoice() const {
  auto swig_cres = inworld_ToolChoice_GetStringChoice(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline FunctionChoice ToolChoice::GetFunctionChoice() const {
  auto swig_cres = inworld_ToolChoice_GetFunctionChoice(swig_self());
  return FunctionChoice{swig_cres, true};
}
inline void ToolChoice::SetStringChoice(std::string const& choice) { inworld_ToolChoice_SetStringChoice(swig_self(), (&choice)->c_str()); }
inline void ToolChoice::SetFunctionChoice(FunctionChoice const & func_choice) { inworld_ToolChoice_SetFunctionChoice(swig_self(), func_choice.swig_self()); }
inline ToolChoice::ToolChoice() : ToolChoice{inworld_ToolChoice_new()} {}
inline ToolChoice::ToolChoice(ToolChoice const & other) : ToolChoice{inworld_ToolChoice_copy(other.swig_self())} {}
inline void ToolCall::id(std::string const& id) { inworld_ToolCall_id_set(swig_self(), (&id)->c_str()); }
inline std::string ToolCall::id() const {
  auto swig_cres = inworld_ToolCall_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void ToolCall::name(std::string const& name) { inworld_ToolCall_name_set(swig_self(), (&name)->c_str()); }
inline std::string ToolCall::name() const {
  auto swig_cres = inworld_ToolCall_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void ToolCall::args(std::string const& args) { inworld_ToolCall_args_set(swig_self(), (&args)->c_str()); }
inline std::string ToolCall::args() const {
  auto swig_cres = inworld_ToolCall_args_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline ToolCall::ToolCall() : ToolCall{inworld_ToolCall_new()} {}
inline ToolCall::ToolCall(ToolCall const & other) : ToolCall{inworld_ToolCall_copy(other.swig_self())} {}
inline void ImageUrl::url(std::string const& url) { inworld_ImageUrl_url_set(swig_self(), (&url)->c_str()); }
inline std::string ImageUrl::url() const {
  auto swig_cres = inworld_ImageUrl_url_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void ImageUrl::detail(std::string const& detail) { inworld_ImageUrl_detail_set(swig_self(), (&detail)->c_str()); }
inline std::string ImageUrl::detail() const {
  auto swig_cres = inworld_ImageUrl_detail_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline ImageUrl::ImageUrl() : ImageUrl{inworld_ImageUrl_new()} {}
inline ImageUrl::ImageUrl(ImageUrl const & other) : ImageUrl{inworld_ImageUrl_copy(other.swig_self())} {}
inline bool ContentItem::IsText() const { return inworld_ContentItem_IsText(swig_self()); }
inline bool ContentItem::IsImage() const { return inworld_ContentItem_IsImage(swig_self()); }
inline std::string ContentItem::GetText() const {
  auto swig_cres = inworld_ContentItem_GetText(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline ImageUrl ContentItem::GetImageUrl() const {
  auto swig_cres = inworld_ContentItem_GetImageUrl(swig_self());
  return ImageUrl{swig_cres, true};
}
inline void ContentItem::SetText(std::string const& text) { inworld_ContentItem_SetText(swig_self(), (&text)->c_str()); }
inline void ContentItem::SetImageUrl(ImageUrl const & image_url) { inworld_ContentItem_SetImageUrl(swig_self(), image_url.swig_self()); }
inline ContentItem::ContentItem() : ContentItem{inworld_ContentItem_new()} {}
inline ContentItem::ContentItem(ContentItem const & other) : ContentItem{inworld_ContentItem_copy(other.swig_self())} {}
inline void Message::role(std::string const& role) { inworld_Message_role_set(swig_self(), (&role)->c_str()); }
inline std::string Message::role() const {
  auto swig_cres = inworld_Message_role_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Message::tool_calls(ToolCalls * tool_calls) { inworld_Message_tool_calls_set(swig_self(), tool_calls->swig_self()); }
inline ToolCalls * Message::tool_calls() const {
  auto swig_cres = inworld_Message_tool_calls_get(swig_self());
  return swig_cres ? new ToolCalls(swig_cres, false) : nullptr;
}
inline void Message::tool_call_id(std::string const& tool_call_id) { inworld_Message_tool_call_id_set(swig_self(), (&tool_call_id)->c_str()); }
inline std::string Message::tool_call_id() const {
  auto swig_cres = inworld_Message_tool_call_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline bool Message::IsTextContent() const { return inworld_Message_IsTextContent(swig_self()); }
inline bool Message::IsMultimodalContent() const { return inworld_Message_IsMultimodalContent(swig_self()); }
inline std::string Message::GetTextContent() const {
  auto swig_cres = inworld_Message_GetTextContent(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline ContentItems Message::GetContentItems() const {
  auto swig_cres = inworld_Message_GetContentItems(swig_self());
  return ContentItems{swig_cres, true};
}
inline void Message::SetTextContent(std::string const& text) { inworld_Message_SetTextContent(swig_self(), (&text)->c_str()); }
inline void Message::SetContentItems(ContentItems const & content_items) { inworld_Message_SetContentItems(swig_self(), content_items.swig_self()); }
inline Message::Message() : Message{inworld_Message_new()} {}
inline Message::Message(Message const & other) : Message{inworld_Message_copy(other.swig_self())} {}
inline void Content::content(std::string const& content) { inworld_Content_content_set(swig_self(), (&content)->c_str()); }
inline std::string Content::content() const {
  auto swig_cres = inworld_Content_content_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Content::tool_calls(ToolCalls * tool_calls) { inworld_Content_tool_calls_set(swig_self(), tool_calls->swig_self()); }
inline ToolCalls * Content::tool_calls() const {
  auto swig_cres = inworld_Content_tool_calls_get(swig_self());
  return swig_cres ? new ToolCalls(swig_cres, false) : nullptr;
}
inline Content::Content() : Content{inworld_Content_new()} {}
inline Content::Content(Content const & other) : Content{inworld_Content_copy(other.swig_self())} {}
inline bool LLMInterface::is_valid() const { return inworld_LLMInterface_is_valid(swig_self()); }
inline StatusOr_InputStream_Content LLMInterface::GenerateContent(std::string const& prompt) const {
  auto swig_cres = inworld_LLMInterface_GenerateContent_rcstd_string(swig_self(), (&prompt)->c_str());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content LLMInterface::GenerateContent(std::string const& prompt, TextGenerationConfig const & arg3) const {
  auto swig_cres = inworld_LLMInterface_GenerateContent_rcstd_string_rcinworld_TextGenerationConfig(swig_self(), (&prompt)->c_str(), arg3.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content LLMInterface::GenerateContent(Messages const & messages, TextGenerationConfig const & arg3) const {
  auto swig_cres = inworld_LLMInterface_GenerateContent_rcstd_vector_Sl_inworld_Message_Sg__rcinworld_TextGenerationConfig(swig_self(), messages.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content LLMInterface::GenerateContent(Messages const & messages, Vector_Tool const & arg3) const {
  auto swig_cres = inworld_LLMInterface_GenerateContent_rcstd_vector_Sl_inworld_Message_Sg__rcstd_vector_Sl_inworld_Tool_Sg_(swig_self(), messages.swig_self(), arg3.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content LLMInterface::GenerateContent(Messages const & messages, TextGenerationConfig const & arg3, Vector_Tool const & arg4) const {
  auto swig_cres = inworld_LLMInterface_GenerateContent_rcstd_vector_Sl_inworld_Message_Sg__rcinworld_TextGenerationConfig_rcstd_vector_Sl_inworld_Tool_Sg_(swig_self(), messages.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content LLMInterface::GenerateContent(Messages const & messages, Vector_Tool const & arg3, ToolChoice const & arg4) const {
  auto swig_cres = inworld_LLMInterface_GenerateContent_rcstd_vector_Sl_inworld_Message_Sg__rcstd_vector_Sl_inworld_Tool_Sg__rcinworld_ToolChoice(swig_self(), messages.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline StatusOr_InputStream_Content LLMInterface::GenerateContent(Messages const & messages, TextGenerationConfig const & arg3, Vector_Tool const & arg4, ToolChoice const & arg5) const {
  auto swig_cres = inworld_LLMInterface_GenerateContent_rcstd_vector_Sl_inworld_Message_Sg__rcinworld_TextGenerationConfig_rcstd_vector_Sl_inworld_Tool_Sg__rcinworld_ToolChoice(swig_self(), messages.swig_self(), arg3.swig_self(), arg4.swig_self(), arg5.swig_self());
  return StatusOr_InputStream_Content{swig_cres, true};
}
inline optional_LocalLLMConfig::optional_LocalLLMConfig() : optional_LocalLLMConfig{inworld_optional_LocalLLMConfig_new()} {}
inline optional_LocalLLMConfig::optional_LocalLLMConfig(LocalLLMConfig const & value) : optional_LocalLLMConfig{inworld_optional_LocalLLMConfig_new_rcinworld_LocalLLMConfig(value.swig_self())} {}
inline optional_LocalLLMConfig::optional_LocalLLMConfig(optional_LocalLLMConfig const & other) : optional_LocalLLMConfig{inworld_optional_LocalLLMConfig_copy(other.swig_self())} {}
inline bool optional_LocalLLMConfig::has_value() const { return inworld_optional_LocalLLMConfig_has_value(swig_self()); }
inline LocalLLMConfig optional_LocalLLMConfig::value() {
  auto swig_cres = inworld_optional_LocalLLMConfig_value(swig_self());
  return LocalLLMConfig{swig_cres, false};
}
inline LocalLLMConfig optional_LocalLLMConfig::value() const {
  auto swig_cres = inworld_optional_LocalLLMConfig_valueConst(swig_self());
  return LocalLLMConfig{swig_cres, false};
}
inline LocalLLMConfig optional_LocalLLMConfig::value_or(LocalLLMConfig const & default_value) const {
  auto swig_cres = inworld_optional_LocalLLMConfig_value_or(swig_self(), default_value.swig_self());
  return LocalLLMConfig{swig_cres, true};
}
inline void optional_LocalLLMConfig::reset() { inworld_optional_LocalLLMConfig_reset(swig_self()); }
inline LocalLLMConfig optional_LocalLLMConfig::operator *() {
  auto swig_cres = inworld_optional_LocalLLMConfig_get(swig_self());
  return LocalLLMConfig{swig_cres, false};
}
inline LocalLLMConfig optional_LocalLLMConfig::operator *() const {
  auto swig_cres = inworld_optional_LocalLLMConfig_getConst(swig_self());
  return LocalLLMConfig{swig_cres, false};
}
inline LocalLLMConfig optional_LocalLLMConfig::get_value() {
  auto swig_cres = inworld_optional_LocalLLMConfig_get_value(swig_self());
  return LocalLLMConfig{swig_cres, false};
}
inline void optional_LocalLLMConfig::set_value(LocalLLMConfig & t) { inworld_optional_LocalLLMConfig_set_value(swig_self(), t.swig_self()); }
inline optional_RemoteLLMConfig::optional_RemoteLLMConfig() : optional_RemoteLLMConfig{inworld_optional_RemoteLLMConfig_new()} {}
inline optional_RemoteLLMConfig::optional_RemoteLLMConfig(RemoteLLMConfig const & value) : optional_RemoteLLMConfig{inworld_optional_RemoteLLMConfig_new_rcinworld_RemoteLLMConfig(value.swig_self())} {}
inline optional_RemoteLLMConfig::optional_RemoteLLMConfig(optional_RemoteLLMConfig const & other) : optional_RemoteLLMConfig{inworld_optional_RemoteLLMConfig_copy(other.swig_self())} {}
inline bool optional_RemoteLLMConfig::has_value() const { return inworld_optional_RemoteLLMConfig_has_value(swig_self()); }
inline RemoteLLMConfig optional_RemoteLLMConfig::value() {
  auto swig_cres = inworld_optional_RemoteLLMConfig_value(swig_self());
  return RemoteLLMConfig{swig_cres, false};
}
inline RemoteLLMConfig optional_RemoteLLMConfig::value() const {
  auto swig_cres = inworld_optional_RemoteLLMConfig_valueConst(swig_self());
  return RemoteLLMConfig{swig_cres, false};
}
inline RemoteLLMConfig optional_RemoteLLMConfig::value_or(RemoteLLMConfig const & default_value) const {
  auto swig_cres = inworld_optional_RemoteLLMConfig_value_or(swig_self(), default_value.swig_self());
  return RemoteLLMConfig{swig_cres, true};
}
inline void optional_RemoteLLMConfig::reset() { inworld_optional_RemoteLLMConfig_reset(swig_self()); }
inline RemoteLLMConfig optional_RemoteLLMConfig::operator *() {
  auto swig_cres = inworld_optional_RemoteLLMConfig_get(swig_self());
  return RemoteLLMConfig{swig_cres, false};
}
inline RemoteLLMConfig optional_RemoteLLMConfig::operator *() const {
  auto swig_cres = inworld_optional_RemoteLLMConfig_getConst(swig_self());
  return RemoteLLMConfig{swig_cres, false};
}
inline RemoteLLMConfig optional_RemoteLLMConfig::get_value() {
  auto swig_cres = inworld_optional_RemoteLLMConfig_get_value(swig_self());
  return RemoteLLMConfig{swig_cres, false};
}
inline void optional_RemoteLLMConfig::set_value(RemoteLLMConfig & t) { inworld_optional_RemoteLLMConfig_set_value(swig_self(), t.swig_self()); }
inline void LocalLLMConfig::model_path(std::string const& model_path) { inworld_LocalLLMConfig_model_path_set(swig_self(), (&model_path)->c_str()); }
inline std::string LocalLLMConfig::model_path() const {
  auto swig_cres = inworld_LocalLLMConfig_model_path_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LocalLLMConfig::device(Device * device) { inworld_LocalLLMConfig_device_set(swig_self(), device->swig_self()); }
inline Device * LocalLLMConfig::device() const {
  auto swig_cres = inworld_LocalLLMConfig_device_get(swig_self());
  return swig_cres ? new Device(swig_cres, false) : nullptr;
}
inline void LocalLLMConfig::default_config(TextGenerationConfig * default_config) { inworld_LocalLLMConfig_default_config_set(swig_self(), default_config->swig_self()); }
inline TextGenerationConfig * LocalLLMConfig::default_config() const {
  auto swig_cres = inworld_LocalLLMConfig_default_config_get(swig_self());
  return swig_cres ? new TextGenerationConfig(swig_cres, false) : nullptr;
}
inline LocalLLMConfig::LocalLLMConfig() : LocalLLMConfig{inworld_LocalLLMConfig_new()} {}
inline LocalLLMConfig::LocalLLMConfig(LocalLLMConfig const & other) : LocalLLMConfig{inworld_LocalLLMConfig_copy(other.swig_self())} {}
inline void RemoteLLMConfig::provider(std::string const& provider) { inworld_RemoteLLMConfig_provider_set(swig_self(), (&provider)->c_str()); }
inline std::string RemoteLLMConfig::provider() const {
  auto swig_cres = inworld_RemoteLLMConfig_provider_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RemoteLLMConfig::model_name(std::string const& model_name) { inworld_RemoteLLMConfig_model_name_set(swig_self(), (&model_name)->c_str()); }
inline std::string RemoteLLMConfig::model_name() const {
  auto swig_cres = inworld_RemoteLLMConfig_model_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RemoteLLMConfig::api_key(std::string const& api_key) { inworld_RemoteLLMConfig_api_key_set(swig_self(), (&api_key)->c_str()); }
inline std::string RemoteLLMConfig::api_key() const {
  auto swig_cres = inworld_RemoteLLMConfig_api_key_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RemoteLLMConfig::default_config(TextGenerationConfig * default_config) { inworld_RemoteLLMConfig_default_config_set(swig_self(), default_config->swig_self()); }
inline TextGenerationConfig * RemoteLLMConfig::default_config() const {
  auto swig_cres = inworld_RemoteLLMConfig_default_config_get(swig_self());
  return swig_cres ? new TextGenerationConfig(swig_cres, false) : nullptr;
}
inline RemoteLLMConfig::RemoteLLMConfig() : RemoteLLMConfig{inworld_RemoteLLMConfig_new()} {}
inline RemoteLLMConfig::RemoteLLMConfig(RemoteLLMConfig const & other) : RemoteLLMConfig{inworld_RemoteLLMConfig_copy(other.swig_self())} {}
inline bool LLMCreationConfig::has_local_llm_config() const { return inworld_LLMCreationConfig_has_local_llm_config(swig_self()); }
inline bool LLMCreationConfig::has_remote_llm_config() const { return inworld_LLMCreationConfig_has_remote_llm_config(swig_self()); }
inline optional_LocalLLMConfig LLMCreationConfig::get_local_llm_config() const {
  auto swig_cres = inworld_LLMCreationConfig_get_local_llm_config(swig_self());
  return optional_LocalLLMConfig{swig_cres, true};
}
inline optional_RemoteLLMConfig LLMCreationConfig::get_remote_llm_config() const {
  auto swig_cres = inworld_LLMCreationConfig_get_remote_llm_config(swig_self());
  return optional_RemoteLLMConfig{swig_cres, true};
}
inline void LLMCreationConfig::set_local_llm_config(LocalLLMConfig const & config) { inworld_LLMCreationConfig_set_local_llm_config(swig_self(), config.swig_self()); }
inline void LLMCreationConfig::set_remote_llm_config(RemoteLLMConfig const & config) { inworld_LLMCreationConfig_set_remote_llm_config(swig_self(), config.swig_self()); }
inline LLMCreationConfig::LLMCreationConfig() : LLMCreationConfig{inworld_LLMCreationConfig_new()} {}
inline LLMCreationConfig::LLMCreationConfig(LLMCreationConfig const & other) : LLMCreationConfig{inworld_LLMCreationConfig_copy(other.swig_self())} {}
inline StatusOr_LLMInterface LLMFactory::CreateLLM(LocalLLMConfig const & config) const {
  auto swig_cres = inworld_LLMFactory_CreateLLM_rcinworld_LocalLLMConfig(swig_self(), config.swig_self());
  return StatusOr_LLMInterface{swig_cres, true};
}
inline StatusOr_LLMInterface LLMFactory::CreateLLM(RemoteLLMConfig const & config) const {
  auto swig_cres = inworld_LLMFactory_CreateLLM_rcinworld_RemoteLLMConfig(swig_self(), config.swig_self());
  return StatusOr_LLMInterface{swig_cres, true};
}
inline LLMFactory::LLMFactory() : LLMFactory{inworld_LLMFactory_new()} {}
inline LLMFactory::LLMFactory(LLMFactory const & other) : LLMFactory{inworld_LLMFactory_copy(other.swig_self())} {}
inline StatusOr_LLMRouting LLMRoutingHelper::CreateLLMRouting(CreationContext const & creation_context, LLMRoutingCreationConfig const & arg2) {
  auto swig_cres = inworld_LLMRoutingHelper_CreateLLMRouting(creation_context.swig_self(), arg2.swig_self());
  return StatusOr_LLMRouting{swig_cres, true};
}
inline LLMRoutingHelper::LLMRoutingHelper() : LLMRoutingHelper{inworld_LLMRoutingHelper_new()} {}
inline LLMRoutingHelper::LLMRoutingHelper(LLMRoutingHelper const & other) : LLMRoutingHelper{inworld_LLMRoutingHelper_copy(other.swig_self())} {}
inline void LLMRoutingConfig::llm_component_id(std::string const& llm_component_id) { inworld_LLMRoutingConfig_llm_component_id_set(swig_self(), (&llm_component_id)->c_str()); }
inline std::string LLMRoutingConfig::llm_component_id() const {
  auto swig_cres = inworld_LLMRoutingConfig_llm_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LLMRoutingConfig::priority(int priority) { inworld_LLMRoutingConfig_priority_set(swig_self(), priority); }
inline int LLMRoutingConfig::priority() const { return inworld_LLMRoutingConfig_priority_get(swig_self()); }
inline void LLMRoutingConfig::error_cooldown(Duration * error_cooldown) { inworld_LLMRoutingConfig_error_cooldown_set(swig_self(), error_cooldown->swig_self()); }
inline Duration * LLMRoutingConfig::error_cooldown() const {
  auto swig_cres = inworld_LLMRoutingConfig_error_cooldown_get(swig_self());
  return swig_cres ? new Duration(swig_cres, false) : nullptr;
}
inline void LLMRoutingConfig::min_errors(int min_errors) { inworld_LLMRoutingConfig_min_errors_set(swig_self(), min_errors); }
inline int LLMRoutingConfig::min_errors() const { return inworld_LLMRoutingConfig_min_errors_get(swig_self()); }
inline LLMRoutingConfig::LLMRoutingConfig() : LLMRoutingConfig{inworld_LLMRoutingConfig_new()} {}
inline LLMRoutingConfig::LLMRoutingConfig(LLMRoutingConfig const & other) : LLMRoutingConfig{inworld_LLMRoutingConfig_copy(other.swig_self())} {}
inline void LLMRoutingCreationConfig::routing_configs(vector_LLMRoutingConfig * routing_configs) { inworld_LLMRoutingCreationConfig_routing_configs_set(swig_self(), routing_configs->swig_self()); }
inline vector_LLMRoutingConfig * LLMRoutingCreationConfig::routing_configs() const {
  auto swig_cres = inworld_LLMRoutingCreationConfig_routing_configs_get(swig_self());
  return swig_cres ? new vector_LLMRoutingConfig(swig_cres, false) : nullptr;
}
inline LLMRoutingCreationConfig::LLMRoutingCreationConfig() : LLMRoutingCreationConfig{inworld_LLMRoutingCreationConfig_new()} {}
inline LLMRoutingCreationConfig::LLMRoutingCreationConfig(LLMRoutingCreationConfig const & other) : LLMRoutingCreationConfig{inworld_LLMRoutingCreationConfig_copy(other.swig_self())} {}
inline bool LLMRouting::is_valid() const { return inworld_LLMRouting_is_valid(swig_self()); }
inline void KnowledgeRecord::text(std::string const& text) { inworld_KnowledgeRecord_text_set(swig_self(), (&text)->c_str()); }
inline std::string KnowledgeRecord::text() const {
  auto swig_cres = inworld_KnowledgeRecord_text_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void KnowledgeRecord::embedding(vector_float * embedding) { inworld_KnowledgeRecord_embedding_set(swig_self(), embedding->swig_self()); }
inline vector_float * KnowledgeRecord::embedding() const {
  auto swig_cres = inworld_KnowledgeRecord_embedding_get(swig_self());
  return swig_cres ? new vector_float(swig_cres, false) : nullptr;
}
inline void KnowledgeRecord::metadata(vector_string * metadata) { inworld_KnowledgeRecord_metadata_set(swig_self(), metadata->swig_self()); }
inline vector_string * KnowledgeRecord::metadata() const {
  auto swig_cres = inworld_KnowledgeRecord_metadata_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline KnowledgeRecord::KnowledgeRecord() : KnowledgeRecord{inworld_KnowledgeRecord_new()} {}
inline KnowledgeRecord::KnowledgeRecord(KnowledgeRecord const & other) : KnowledgeRecord{inworld_KnowledgeRecord_copy(other.swig_self())} {}
inline void KnowledgeCollection::knowledge_records(vector_KnowledgeRecord * knowledge_records) { inworld_KnowledgeCollection_knowledge_records_set(swig_self(), knowledge_records->swig_self()); }
inline vector_KnowledgeRecord * KnowledgeCollection::knowledge_records() const {
  auto swig_cres = inworld_KnowledgeCollection_knowledge_records_get(swig_self());
  return swig_cres ? new vector_KnowledgeRecord(swig_cres, false) : nullptr;
}
inline KnowledgeCollection::KnowledgeCollection() : KnowledgeCollection{inworld_KnowledgeCollection_new()} {}
inline KnowledgeCollection::KnowledgeCollection(KnowledgeCollection const & other) : KnowledgeCollection{inworld_KnowledgeCollection_copy(other.swig_self())} {}
inline void RetrievalConfig::threshold(float threshold) { inworld_RetrievalConfig_threshold_set(swig_self(), threshold); }
inline float RetrievalConfig::threshold() const { return inworld_RetrievalConfig_threshold_get(swig_self()); }
inline void RetrievalConfig::top_k(int top_k) { inworld_RetrievalConfig_top_k_set(swig_self(), top_k); }
inline int RetrievalConfig::top_k() const { return inworld_RetrievalConfig_top_k_get(swig_self()); }
inline RetrievalConfig::RetrievalConfig() : RetrievalConfig{inworld_RetrievalConfig_new()} {}
inline RetrievalConfig::RetrievalConfig(RetrievalConfig const & other) : RetrievalConfig{inworld_RetrievalConfig_copy(other.swig_self())} {}
inline bool KnowledgeRetrieverInterface::is_valid() const { return inworld_KnowledgeRetrieverInterface_is_valid(swig_self()); }
inline StatusOr_vector_string KnowledgeRetrieverInterface::RetrieveKnowledge(RetrievalConfig const & config, vector_KnowledgeCollection const & arg3, vector_Event const & arg4) const {
  auto swig_cres = inworld_KnowledgeRetrieverInterface_RetrieveKnowledge(swig_self(), config.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_vector_string{swig_cres, true};
}
inline void File::content(FileContent * content) { inworld_File_content_set(swig_self(), content->swig_self()); }
inline FileContent * File::content() const {
  auto swig_cres = inworld_File_content_get(swig_self());
  return swig_cres ? new FileContent(swig_cres, false) : nullptr;
}
inline void File::type(File::Type type) { inworld_File_type_set(swig_self(), (inworld_File_Type)type); }
inline File::Type File::type() const {
  auto swig_cres = inworld_File_type_get(swig_self());
  return (File::Type)swig_cres;
}
inline File::File() : File{inworld_File_new()} {}
inline File::File(File const & other) : File{inworld_File_copy(other.swig_self())} {}
inline void FileContent::bytes(vector_char * bytes) { inworld_FileContent_bytes_set(swig_self(), bytes->swig_self()); }
inline vector_char * FileContent::bytes() const {
  auto swig_cres = inworld_FileContent_bytes_get(swig_self());
  return swig_cres ? new vector_char(swig_cres, false) : nullptr;
}
inline FileContent::FileContent() : FileContent{inworld_FileContent_new()} {}
inline FileContent::FileContent(FileContent const & other) : FileContent{inworld_FileContent_copy(other.swig_self())} {}
inline void ParsingConfig::max_chars_per_chunk(int max_chars_per_chunk) { inworld_ParsingConfig_max_chars_per_chunk_set(swig_self(), max_chars_per_chunk); }
inline int ParsingConfig::max_chars_per_chunk() const { return inworld_ParsingConfig_max_chars_per_chunk_get(swig_self()); }
inline void ParsingConfig::max_chunks_per_document(int max_chunks_per_document) { inworld_ParsingConfig_max_chunks_per_document_set(swig_self(), max_chunks_per_document); }
inline int ParsingConfig::max_chunks_per_document() const { return inworld_ParsingConfig_max_chunks_per_document_get(swig_self()); }
inline ParsingConfig::ParsingConfig() : ParsingConfig{inworld_ParsingConfig_new()} {}
inline ParsingConfig::ParsingConfig(ParsingConfig const & other) : ParsingConfig{inworld_ParsingConfig_copy(other.swig_self())} {}
inline void KnowledgeCompileConfig::parsing_config(ParsingConfig * parsing_config) { inworld_KnowledgeCompileConfig_parsing_config_set(swig_self(), parsing_config->swig_self()); }
inline ParsingConfig * KnowledgeCompileConfig::parsing_config() const {
  auto swig_cres = inworld_KnowledgeCompileConfig_parsing_config_get(swig_self());
  return swig_cres ? new ParsingConfig(swig_cres, false) : nullptr;
}
inline KnowledgeCompileConfig::KnowledgeCompileConfig() : KnowledgeCompileConfig{inworld_KnowledgeCompileConfig_new()} {}
inline KnowledgeCompileConfig::KnowledgeCompileConfig(KnowledgeCompileConfig const & other) : KnowledgeCompileConfig{inworld_KnowledgeCompileConfig_copy(other.swig_self())} {}
inline Status KnowledgeInterface::RemoveKnowledge(std::string const& knowledge_id) const {
  auto swig_cres = inworld_KnowledgeInterface_RemoveKnowledge(swig_self(), (&knowledge_id)->c_str());
  return Status{swig_cres, true};
}
inline bool KnowledgeInterface::is_valid() const { return inworld_KnowledgeInterface_is_valid(swig_self()); }
inline StatusOr_vector_string KnowledgeInterface::GetKnowledge(vector_string const & ids, vector_Event const & arg3) const {
  auto swig_cres = inworld_KnowledgeInterface_GetKnowledge(swig_self(), ids.swig_self(), arg3.swig_self());
  return StatusOr_vector_string{swig_cres, true};
}
inline StatusOr_vector_string KnowledgeInterface::CompileKnowledge(std::string const& knowledge_id, vector_string const & arg3) const {
  auto swig_cres = inworld_KnowledgeInterface_CompileKnowledge_rcstd_string_rcstd_vector_Sl_std_string_Sg_(swig_self(), (&knowledge_id)->c_str(), arg3.swig_self());
  return StatusOr_vector_string{swig_cres, true};
}
inline StatusOr_vector_string KnowledgeInterface::CompileKnowledge(std::string const& knowledge_id, vector_char const& arg3, File::Type arg4) const {
  auto swig_cres = inworld_KnowledgeInterface_CompileKnowledge_rcstd_string_cstd_vector_Sl_char_Sg__ceType(swig_self(), (&knowledge_id)->c_str(), arg3.swig_self(), (inworld_File_Type)arg4);
  return StatusOr_vector_string{swig_cres, true};
}
inline optional_LocalKnowledgeConfig::optional_LocalKnowledgeConfig() : optional_LocalKnowledgeConfig{inworld_optional_LocalKnowledgeConfig_new()} {}
inline optional_LocalKnowledgeConfig::optional_LocalKnowledgeConfig(LocalKnowledgeConfig const & value) : optional_LocalKnowledgeConfig{inworld_optional_LocalKnowledgeConfig_new_rcinworld_LocalKnowledgeConfig(value.swig_self())} {}
inline optional_LocalKnowledgeConfig::optional_LocalKnowledgeConfig(optional_LocalKnowledgeConfig const & other) : optional_LocalKnowledgeConfig{inworld_optional_LocalKnowledgeConfig_copy(other.swig_self())} {}
inline bool optional_LocalKnowledgeConfig::has_value() const { return inworld_optional_LocalKnowledgeConfig_has_value(swig_self()); }
inline LocalKnowledgeConfig optional_LocalKnowledgeConfig::value() {
  auto swig_cres = inworld_optional_LocalKnowledgeConfig_value(swig_self());
  return LocalKnowledgeConfig{swig_cres, false};
}
inline LocalKnowledgeConfig optional_LocalKnowledgeConfig::value() const {
  auto swig_cres = inworld_optional_LocalKnowledgeConfig_valueConst(swig_self());
  return LocalKnowledgeConfig{swig_cres, false};
}
inline LocalKnowledgeConfig optional_LocalKnowledgeConfig::value_or(LocalKnowledgeConfig const & default_value) const {
  auto swig_cres = inworld_optional_LocalKnowledgeConfig_value_or(swig_self(), default_value.swig_self());
  return LocalKnowledgeConfig{swig_cres, true};
}
inline void optional_LocalKnowledgeConfig::reset() { inworld_optional_LocalKnowledgeConfig_reset(swig_self()); }
inline LocalKnowledgeConfig optional_LocalKnowledgeConfig::operator *() {
  auto swig_cres = inworld_optional_LocalKnowledgeConfig_get(swig_self());
  return LocalKnowledgeConfig{swig_cres, false};
}
inline LocalKnowledgeConfig optional_LocalKnowledgeConfig::operator *() const {
  auto swig_cres = inworld_optional_LocalKnowledgeConfig_getConst(swig_self());
  return LocalKnowledgeConfig{swig_cres, false};
}
inline LocalKnowledgeConfig optional_LocalKnowledgeConfig::get_value() {
  auto swig_cres = inworld_optional_LocalKnowledgeConfig_get_value(swig_self());
  return LocalKnowledgeConfig{swig_cres, false};
}
inline void optional_LocalKnowledgeConfig::set_value(LocalKnowledgeConfig & t) { inworld_optional_LocalKnowledgeConfig_set_value(swig_self(), t.swig_self()); }
inline optional_RemoteKnowledgeConfig::optional_RemoteKnowledgeConfig() : optional_RemoteKnowledgeConfig{inworld_optional_RemoteKnowledgeConfig_new()} {}
inline optional_RemoteKnowledgeConfig::optional_RemoteKnowledgeConfig(RemoteKnowledgeConfig const & value) : optional_RemoteKnowledgeConfig{inworld_optional_RemoteKnowledgeConfig_new_rcinworld_RemoteKnowledgeConfig(value.swig_self())} {}
inline optional_RemoteKnowledgeConfig::optional_RemoteKnowledgeConfig(optional_RemoteKnowledgeConfig const & other) : optional_RemoteKnowledgeConfig{inworld_optional_RemoteKnowledgeConfig_copy(other.swig_self())} {}
inline bool optional_RemoteKnowledgeConfig::has_value() const { return inworld_optional_RemoteKnowledgeConfig_has_value(swig_self()); }
inline RemoteKnowledgeConfig optional_RemoteKnowledgeConfig::value() {
  auto swig_cres = inworld_optional_RemoteKnowledgeConfig_value(swig_self());
  return RemoteKnowledgeConfig{swig_cres, false};
}
inline RemoteKnowledgeConfig optional_RemoteKnowledgeConfig::value() const {
  auto swig_cres = inworld_optional_RemoteKnowledgeConfig_valueConst(swig_self());
  return RemoteKnowledgeConfig{swig_cres, false};
}
inline RemoteKnowledgeConfig optional_RemoteKnowledgeConfig::value_or(RemoteKnowledgeConfig const & default_value) const {
  auto swig_cres = inworld_optional_RemoteKnowledgeConfig_value_or(swig_self(), default_value.swig_self());
  return RemoteKnowledgeConfig{swig_cres, true};
}
inline void optional_RemoteKnowledgeConfig::reset() { inworld_optional_RemoteKnowledgeConfig_reset(swig_self()); }
inline RemoteKnowledgeConfig optional_RemoteKnowledgeConfig::operator *() {
  auto swig_cres = inworld_optional_RemoteKnowledgeConfig_get(swig_self());
  return RemoteKnowledgeConfig{swig_cres, false};
}
inline RemoteKnowledgeConfig optional_RemoteKnowledgeConfig::operator *() const {
  auto swig_cres = inworld_optional_RemoteKnowledgeConfig_getConst(swig_self());
  return RemoteKnowledgeConfig{swig_cres, false};
}
inline RemoteKnowledgeConfig optional_RemoteKnowledgeConfig::get_value() {
  auto swig_cres = inworld_optional_RemoteKnowledgeConfig_get_value(swig_self());
  return RemoteKnowledgeConfig{swig_cres, false};
}
inline void optional_RemoteKnowledgeConfig::set_value(RemoteKnowledgeConfig & t) { inworld_optional_RemoteKnowledgeConfig_set_value(swig_self(), t.swig_self()); }
inline void LocalKnowledgeConfig::knowledge_compile_config(KnowledgeCompileConfig * knowledge_compile_config) { inworld_LocalKnowledgeConfig_knowledge_compile_config_set(swig_self(), knowledge_compile_config->swig_self()); }
inline KnowledgeCompileConfig * LocalKnowledgeConfig::knowledge_compile_config() const {
  auto swig_cres = inworld_LocalKnowledgeConfig_knowledge_compile_config_get(swig_self());
  return swig_cres ? new KnowledgeCompileConfig(swig_cres, false) : nullptr;
}
inline void LocalKnowledgeConfig::embedder_component_id(std::string const& embedder_component_id) { inworld_LocalKnowledgeConfig_embedder_component_id_set(swig_self(), (&embedder_component_id)->c_str()); }
inline std::string LocalKnowledgeConfig::embedder_component_id() const {
  auto swig_cres = inworld_LocalKnowledgeConfig_embedder_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline LocalKnowledgeConfig::LocalKnowledgeConfig() : LocalKnowledgeConfig{inworld_LocalKnowledgeConfig_new()} {}
inline LocalKnowledgeConfig::LocalKnowledgeConfig(LocalKnowledgeConfig const & other) : LocalKnowledgeConfig{inworld_LocalKnowledgeConfig_copy(other.swig_self())} {}
inline void RemoteKnowledgeConfig::knowledge_compile_config(KnowledgeCompileConfig * knowledge_compile_config) { inworld_RemoteKnowledgeConfig_knowledge_compile_config_set(swig_self(), knowledge_compile_config->swig_self()); }
inline KnowledgeCompileConfig * RemoteKnowledgeConfig::knowledge_compile_config() const {
  auto swig_cres = inworld_RemoteKnowledgeConfig_knowledge_compile_config_get(swig_self());
  return swig_cres ? new KnowledgeCompileConfig(swig_cres, false) : nullptr;
}
inline void RemoteKnowledgeConfig::api_key(std::string const& api_key) { inworld_RemoteKnowledgeConfig_api_key_set(swig_self(), (&api_key)->c_str()); }
inline std::string RemoteKnowledgeConfig::api_key() const {
  auto swig_cres = inworld_RemoteKnowledgeConfig_api_key_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RemoteKnowledgeConfig::language(Language * language) { inworld_RemoteKnowledgeConfig_language_set(swig_self(), language->swig_self()); }
inline Language * RemoteKnowledgeConfig::language() const {
  auto swig_cres = inworld_RemoteKnowledgeConfig_language_get(swig_self());
  return swig_cres ? new Language(swig_cres, false) : nullptr;
}
inline RemoteKnowledgeConfig::RemoteKnowledgeConfig() : RemoteKnowledgeConfig{inworld_RemoteKnowledgeConfig_new()} {}
inline RemoteKnowledgeConfig::RemoteKnowledgeConfig(RemoteKnowledgeConfig const & other) : RemoteKnowledgeConfig{inworld_RemoteKnowledgeConfig_copy(other.swig_self())} {}
inline bool KnowledgeCreationConfig::has_local_config() { return inworld_KnowledgeCreationConfig_has_local_config(swig_self()); }
inline bool KnowledgeCreationConfig::has_remote_config() { return inworld_KnowledgeCreationConfig_has_remote_config(swig_self()); }
inline optional_LocalKnowledgeConfig KnowledgeCreationConfig::get_local_config() {
  auto swig_cres = inworld_KnowledgeCreationConfig_get_local_config(swig_self());
  return optional_LocalKnowledgeConfig{swig_cres, true};
}
inline optional_RemoteKnowledgeConfig KnowledgeCreationConfig::get_remote_config() {
  auto swig_cres = inworld_KnowledgeCreationConfig_get_remote_config(swig_self());
  return optional_RemoteKnowledgeConfig{swig_cres, true};
}
inline void KnowledgeCreationConfig::set_local_config(LocalKnowledgeConfig const & config) { inworld_KnowledgeCreationConfig_set_local_config(swig_self(), config.swig_self()); }
inline void KnowledgeCreationConfig::set_remote_config(RemoteKnowledgeConfig const & config) { inworld_KnowledgeCreationConfig_set_remote_config(swig_self(), config.swig_self()); }
inline bool KnowledgeCreationConfig::is_valid() const { return inworld_KnowledgeCreationConfig_is_valid(swig_self()); }
inline KnowledgeCreationConfig::KnowledgeCreationConfig() : KnowledgeCreationConfig{inworld_KnowledgeCreationConfig_new()} {}
inline KnowledgeCreationConfig::KnowledgeCreationConfig(KnowledgeCreationConfig const & other) : KnowledgeCreationConfig{inworld_KnowledgeCreationConfig_copy(other.swig_self())} {}
inline StatusOr_KnowledgeInterface KnowledgeFactory::CreateKnowledge(CreationContext const & creation_context, LocalKnowledgeConfig const & arg3) const {
  auto swig_cres = inworld_KnowledgeFactory_CreateKnowledge_rcinworld_CreationContext_rcinworld_LocalKnowledgeConfig(swig_self(), creation_context.swig_self(), arg3.swig_self());
  return StatusOr_KnowledgeInterface{swig_cres, true};
}
inline StatusOr_KnowledgeInterface KnowledgeFactory::CreateKnowledge(CreationContext const & creation_context, RemoteKnowledgeConfig const & arg3) const {
  auto swig_cres = inworld_KnowledgeFactory_CreateKnowledge_rcinworld_CreationContext_rcinworld_RemoteKnowledgeConfig(swig_self(), creation_context.swig_self(), arg3.swig_self());
  return StatusOr_KnowledgeInterface{swig_cres, true};
}
inline KnowledgeFactory::KnowledgeFactory() : KnowledgeFactory{inworld_KnowledgeFactory_new()} {}
inline KnowledgeFactory::KnowledgeFactory(KnowledgeFactory const & other) : KnowledgeFactory{inworld_KnowledgeFactory_copy(other.swig_self())} {}
inline KnowledgeCollection KnowledgeCollectionFactory::CreateKnowledgeCollection(TextEmbedderInterface const& embedder, vector_string const & arg3) const {
  auto swig_cres = inworld_KnowledgeCollectionFactory_CreateKnowledgeCollection(swig_self(), embedder.swig_self(), arg3.swig_self());
  return KnowledgeCollection{swig_cres, true};
}
inline KnowledgeCollectionFactory::KnowledgeCollectionFactory() : KnowledgeCollectionFactory{inworld_KnowledgeCollectionFactory_new()} {}
inline KnowledgeCollectionFactory::KnowledgeCollectionFactory(KnowledgeCollectionFactory const & other) : KnowledgeCollectionFactory{inworld_KnowledgeCollectionFactory_copy(other.swig_self())} {}
inline StatusOr_KnowledgeRetrieverInterface KnowledgeRetrieverFactory::CreateKnowledgeRetriever(TextEmbedderInterface const& embedder) const {
  auto swig_cres = inworld_KnowledgeRetrieverFactory_CreateKnowledgeRetriever(swig_self(), embedder.swig_self());
  return StatusOr_KnowledgeRetrieverInterface{swig_cres, true};
}
inline KnowledgeRetrieverFactory::KnowledgeRetrieverFactory() : KnowledgeRetrieverFactory{inworld_KnowledgeRetrieverFactory_new()} {}
inline KnowledgeRetrieverFactory::KnowledgeRetrieverFactory(KnowledgeRetrieverFactory const & other) : KnowledgeRetrieverFactory{inworld_KnowledgeRetrieverFactory_copy(other.swig_self())} {}
inline optional_RollingSummaryConfig::optional_RollingSummaryConfig() : optional_RollingSummaryConfig{inworld_optional_RollingSummaryConfig_new()} {}
inline optional_RollingSummaryConfig::optional_RollingSummaryConfig(RollingSummaryConfig const & value) : optional_RollingSummaryConfig{inworld_optional_RollingSummaryConfig_new_rcinworld_RollingSummaryConfig(value.swig_self())} {}
inline optional_RollingSummaryConfig::optional_RollingSummaryConfig(optional_RollingSummaryConfig const & other) : optional_RollingSummaryConfig{inworld_optional_RollingSummaryConfig_copy(other.swig_self())} {}
inline bool optional_RollingSummaryConfig::has_value() const { return inworld_optional_RollingSummaryConfig_has_value(swig_self()); }
inline RollingSummaryConfig optional_RollingSummaryConfig::value() {
  auto swig_cres = inworld_optional_RollingSummaryConfig_value(swig_self());
  return RollingSummaryConfig{swig_cres, false};
}
inline RollingSummaryConfig optional_RollingSummaryConfig::value() const {
  auto swig_cres = inworld_optional_RollingSummaryConfig_valueConst(swig_self());
  return RollingSummaryConfig{swig_cres, false};
}
inline RollingSummaryConfig optional_RollingSummaryConfig::value_or(RollingSummaryConfig const & default_value) const {
  auto swig_cres = inworld_optional_RollingSummaryConfig_value_or(swig_self(), default_value.swig_self());
  return RollingSummaryConfig{swig_cres, true};
}
inline void optional_RollingSummaryConfig::reset() { inworld_optional_RollingSummaryConfig_reset(swig_self()); }
inline RollingSummaryConfig optional_RollingSummaryConfig::operator *() {
  auto swig_cres = inworld_optional_RollingSummaryConfig_get(swig_self());
  return RollingSummaryConfig{swig_cres, false};
}
inline RollingSummaryConfig optional_RollingSummaryConfig::operator *() const {
  auto swig_cres = inworld_optional_RollingSummaryConfig_getConst(swig_self());
  return RollingSummaryConfig{swig_cres, false};
}
inline RollingSummaryConfig optional_RollingSummaryConfig::get_value() {
  auto swig_cres = inworld_optional_RollingSummaryConfig_get_value(swig_self());
  return RollingSummaryConfig{swig_cres, false};
}
inline void optional_RollingSummaryConfig::set_value(RollingSummaryConfig & t) { inworld_optional_RollingSummaryConfig_set_value(swig_self(), t.swig_self()); }
inline optional_FlashMemoryConfig::optional_FlashMemoryConfig() : optional_FlashMemoryConfig{inworld_optional_FlashMemoryConfig_new()} {}
inline optional_FlashMemoryConfig::optional_FlashMemoryConfig(FlashMemoryConfig const & value) : optional_FlashMemoryConfig{inworld_optional_FlashMemoryConfig_new_rcinworld_FlashMemoryConfig(value.swig_self())} {}
inline optional_FlashMemoryConfig::optional_FlashMemoryConfig(optional_FlashMemoryConfig const & other) : optional_FlashMemoryConfig{inworld_optional_FlashMemoryConfig_copy(other.swig_self())} {}
inline bool optional_FlashMemoryConfig::has_value() const { return inworld_optional_FlashMemoryConfig_has_value(swig_self()); }
inline FlashMemoryConfig optional_FlashMemoryConfig::value() {
  auto swig_cres = inworld_optional_FlashMemoryConfig_value(swig_self());
  return FlashMemoryConfig{swig_cres, false};
}
inline FlashMemoryConfig optional_FlashMemoryConfig::value() const {
  auto swig_cres = inworld_optional_FlashMemoryConfig_valueConst(swig_self());
  return FlashMemoryConfig{swig_cres, false};
}
inline FlashMemoryConfig optional_FlashMemoryConfig::value_or(FlashMemoryConfig const & default_value) const {
  auto swig_cres = inworld_optional_FlashMemoryConfig_value_or(swig_self(), default_value.swig_self());
  return FlashMemoryConfig{swig_cres, true};
}
inline void optional_FlashMemoryConfig::reset() { inworld_optional_FlashMemoryConfig_reset(swig_self()); }
inline FlashMemoryConfig optional_FlashMemoryConfig::operator *() {
  auto swig_cres = inworld_optional_FlashMemoryConfig_get(swig_self());
  return FlashMemoryConfig{swig_cres, false};
}
inline FlashMemoryConfig optional_FlashMemoryConfig::operator *() const {
  auto swig_cres = inworld_optional_FlashMemoryConfig_getConst(swig_self());
  return FlashMemoryConfig{swig_cres, false};
}
inline FlashMemoryConfig optional_FlashMemoryConfig::get_value() {
  auto swig_cres = inworld_optional_FlashMemoryConfig_get_value(swig_self());
  return FlashMemoryConfig{swig_cres, false};
}
inline void optional_FlashMemoryConfig::set_value(FlashMemoryConfig & t) { inworld_optional_FlashMemoryConfig_set_value(swig_self(), t.swig_self()); }
inline optional_LongTermMemoryConfig::optional_LongTermMemoryConfig() : optional_LongTermMemoryConfig{inworld_optional_LongTermMemoryConfig_new()} {}
inline optional_LongTermMemoryConfig::optional_LongTermMemoryConfig(LongTermMemoryConfig const & value) : optional_LongTermMemoryConfig{inworld_optional_LongTermMemoryConfig_new_rcinworld_LongTermMemoryConfig(value.swig_self())} {}
inline optional_LongTermMemoryConfig::optional_LongTermMemoryConfig(optional_LongTermMemoryConfig const & other) : optional_LongTermMemoryConfig{inworld_optional_LongTermMemoryConfig_copy(other.swig_self())} {}
inline bool optional_LongTermMemoryConfig::has_value() const { return inworld_optional_LongTermMemoryConfig_has_value(swig_self()); }
inline LongTermMemoryConfig optional_LongTermMemoryConfig::value() {
  auto swig_cres = inworld_optional_LongTermMemoryConfig_value(swig_self());
  return LongTermMemoryConfig{swig_cres, false};
}
inline LongTermMemoryConfig optional_LongTermMemoryConfig::value() const {
  auto swig_cres = inworld_optional_LongTermMemoryConfig_valueConst(swig_self());
  return LongTermMemoryConfig{swig_cres, false};
}
inline LongTermMemoryConfig optional_LongTermMemoryConfig::value_or(LongTermMemoryConfig const & default_value) const {
  auto swig_cres = inworld_optional_LongTermMemoryConfig_value_or(swig_self(), default_value.swig_self());
  return LongTermMemoryConfig{swig_cres, true};
}
inline void optional_LongTermMemoryConfig::reset() { inworld_optional_LongTermMemoryConfig_reset(swig_self()); }
inline LongTermMemoryConfig optional_LongTermMemoryConfig::operator *() {
  auto swig_cres = inworld_optional_LongTermMemoryConfig_get(swig_self());
  return LongTermMemoryConfig{swig_cres, false};
}
inline LongTermMemoryConfig optional_LongTermMemoryConfig::operator *() const {
  auto swig_cres = inworld_optional_LongTermMemoryConfig_getConst(swig_self());
  return LongTermMemoryConfig{swig_cres, false};
}
inline LongTermMemoryConfig optional_LongTermMemoryConfig::get_value() {
  auto swig_cres = inworld_optional_LongTermMemoryConfig_get_value(swig_self());
  return LongTermMemoryConfig{swig_cres, false};
}
inline void optional_LongTermMemoryConfig::set_value(LongTermMemoryConfig & t) { inworld_optional_LongTermMemoryConfig_set_value(swig_self(), t.swig_self()); }
inline void RollingSummary::summarized_text(std::string const& summarized_text) { inworld_RollingSummary_summarized_text_set(swig_self(), (&summarized_text)->c_str()); }
inline std::string RollingSummary::summarized_text() const {
  auto swig_cres = inworld_RollingSummary_summarized_text_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RollingSummary::turns_since_last_update(int turns_since_last_update) { inworld_RollingSummary_turns_since_last_update_set(swig_self(), turns_since_last_update); }
inline int RollingSummary::turns_since_last_update() const { return inworld_RollingSummary_turns_since_last_update_get(swig_self()); }
inline RollingSummary::RollingSummary() : RollingSummary{inworld_RollingSummary_new()} {}
inline RollingSummary::RollingSummary(RollingSummary const & other) : RollingSummary{inworld_RollingSummary_copy(other.swig_self())} {}
inline void FlashMemory::knowledge_collection(KnowledgeCollection * knowledge_collection) { inworld_FlashMemory_knowledge_collection_set(swig_self(), knowledge_collection->swig_self()); }
inline KnowledgeCollection * FlashMemory::knowledge_collection() const {
  auto swig_cres = inworld_FlashMemory_knowledge_collection_get(swig_self());
  return swig_cres ? new KnowledgeCollection(swig_cres, false) : nullptr;
}
inline FlashMemory::FlashMemory() : FlashMemory{inworld_FlashMemory_new()} {}
inline FlashMemory::FlashMemory(FlashMemory const & other) : FlashMemory{inworld_FlashMemory_copy(other.swig_self())} {}
inline void LongTermMemory::knowledge_collection(KnowledgeCollection * knowledge_collection) { inworld_LongTermMemory_knowledge_collection_set(swig_self(), knowledge_collection->swig_self()); }
inline KnowledgeCollection * LongTermMemory::knowledge_collection() const {
  auto swig_cres = inworld_LongTermMemory_knowledge_collection_get(swig_self());
  return swig_cres ? new KnowledgeCollection(swig_cres, false) : nullptr;
}
inline LongTermMemory::LongTermMemory() : LongTermMemory{inworld_LongTermMemory_new()} {}
inline LongTermMemory::LongTermMemory(LongTermMemory const & other) : LongTermMemory{inworld_LongTermMemory_copy(other.swig_self())} {}
inline void MemorySnapshot::rolling_summary(RollingSummary * rolling_summary) { inworld_MemorySnapshot_rolling_summary_set(swig_self(), rolling_summary->swig_self()); }
inline RollingSummary * MemorySnapshot::rolling_summary() const {
  auto swig_cres = inworld_MemorySnapshot_rolling_summary_get(swig_self());
  return swig_cres ? new RollingSummary(swig_cres, false) : nullptr;
}
inline void MemorySnapshot::flash_memory(FlashMemory * flash_memory) { inworld_MemorySnapshot_flash_memory_set(swig_self(), flash_memory->swig_self()); }
inline FlashMemory * MemorySnapshot::flash_memory() const {
  auto swig_cres = inworld_MemorySnapshot_flash_memory_get(swig_self());
  return swig_cres ? new FlashMemory(swig_cres, false) : nullptr;
}
inline void MemorySnapshot::long_term_memory(LongTermMemory * long_term_memory) { inworld_MemorySnapshot_long_term_memory_set(swig_self(), long_term_memory->swig_self()); }
inline LongTermMemory * MemorySnapshot::long_term_memory() const {
  auto swig_cres = inworld_MemorySnapshot_long_term_memory_get(swig_self());
  return swig_cres ? new LongTermMemory(swig_cres, false) : nullptr;
}
inline MemorySnapshot::MemorySnapshot() : MemorySnapshot{inworld_MemorySnapshot_new()} {}
inline MemorySnapshot::MemorySnapshot(MemorySnapshot const & other) : MemorySnapshot{inworld_MemorySnapshot_copy(other.swig_self())} {}
inline void RollingSummaryConfig::number_of_turns_before_summary(int number_of_turns_before_summary) { inworld_RollingSummaryConfig_number_of_turns_before_summary_set(swig_self(), number_of_turns_before_summary); }
inline int RollingSummaryConfig::number_of_turns_before_summary() const { return inworld_RollingSummaryConfig_number_of_turns_before_summary_get(swig_self()); }
inline void RollingSummaryConfig::start_window_size(int start_window_size) { inworld_RollingSummaryConfig_start_window_size_set(swig_self(), start_window_size); }
inline int RollingSummaryConfig::start_window_size() const { return inworld_RollingSummaryConfig_start_window_size_get(swig_self()); }
inline void RollingSummaryConfig::text_generation_config(TextGenerationConfig * text_generation_config) { inworld_RollingSummaryConfig_text_generation_config_set(swig_self(), text_generation_config->swig_self()); }
inline TextGenerationConfig * RollingSummaryConfig::text_generation_config() const {
  auto swig_cres = inworld_RollingSummaryConfig_text_generation_config_get(swig_self());
  return swig_cres ? new TextGenerationConfig(swig_cres, false) : nullptr;
}
inline void RollingSummaryConfig::max_summary_sentences(int max_summary_sentences) { inworld_RollingSummaryConfig_max_summary_sentences_set(swig_self(), max_summary_sentences); }
inline int RollingSummaryConfig::max_summary_sentences() const { return inworld_RollingSummaryConfig_max_summary_sentences_get(swig_self()); }
inline RollingSummaryConfig::RollingSummaryConfig() : RollingSummaryConfig{inworld_RollingSummaryConfig_new()} {}
inline RollingSummaryConfig::RollingSummaryConfig(RollingSummaryConfig const & other) : RollingSummaryConfig{inworld_RollingSummaryConfig_copy(other.swig_self())} {}
inline void FlashMemoryConfig::dialogue_cutoff_size(int dialogue_cutoff_size) { inworld_FlashMemoryConfig_dialogue_cutoff_size_set(swig_self(), dialogue_cutoff_size); }
inline int FlashMemoryConfig::dialogue_cutoff_size() const { return inworld_FlashMemoryConfig_dialogue_cutoff_size_get(swig_self()); }
inline void FlashMemoryConfig::n_history_turns(int n_history_turns) { inworld_FlashMemoryConfig_n_history_turns_set(swig_self(), n_history_turns); }
inline int FlashMemoryConfig::n_history_turns() const { return inworld_FlashMemoryConfig_n_history_turns_get(swig_self()); }
inline void FlashMemoryConfig::memories_similarity_threshold(float memories_similarity_threshold) { inworld_FlashMemoryConfig_memories_similarity_threshold_set(swig_self(), memories_similarity_threshold); }
inline float FlashMemoryConfig::memories_similarity_threshold() const { return inworld_FlashMemoryConfig_memories_similarity_threshold_get(swig_self()); }
inline void FlashMemoryConfig::max_flash_memory(int max_flash_memory) { inworld_FlashMemoryConfig_max_flash_memory_set(swig_self(), max_flash_memory); }
inline int FlashMemoryConfig::max_flash_memory() const { return inworld_FlashMemoryConfig_max_flash_memory_get(swig_self()); }
inline void FlashMemoryConfig::max_topics_per_memory(int max_topics_per_memory) { inworld_FlashMemoryConfig_max_topics_per_memory_set(swig_self(), max_topics_per_memory); }
inline int FlashMemoryConfig::max_topics_per_memory() const { return inworld_FlashMemoryConfig_max_topics_per_memory_get(swig_self()); }
inline void FlashMemoryConfig::text_generation_config(TextGenerationConfig * text_generation_config) { inworld_FlashMemoryConfig_text_generation_config_set(swig_self(), text_generation_config->swig_self()); }
inline TextGenerationConfig * FlashMemoryConfig::text_generation_config() const {
  auto swig_cres = inworld_FlashMemoryConfig_text_generation_config_get(swig_self());
  return swig_cres ? new TextGenerationConfig(swig_cres, false) : nullptr;
}
inline FlashMemoryConfig::FlashMemoryConfig() : FlashMemoryConfig{inworld_FlashMemoryConfig_new()} {}
inline FlashMemoryConfig::FlashMemoryConfig(FlashMemoryConfig const & other) : FlashMemoryConfig{inworld_FlashMemoryConfig_copy(other.swig_self())} {}
inline void LongTermMemoryConfig::max_topic_summary_len_to_append(int max_topic_summary_len_to_append) { inworld_LongTermMemoryConfig_max_topic_summary_len_to_append_set(swig_self(), max_topic_summary_len_to_append); }
inline int LongTermMemoryConfig::max_topic_summary_len_to_append() const { return inworld_LongTermMemoryConfig_max_topic_summary_len_to_append_get(swig_self()); }
inline void LongTermMemoryConfig::max_number_of_flash_memory(int max_number_of_flash_memory) { inworld_LongTermMemoryConfig_max_number_of_flash_memory_set(swig_self(), max_number_of_flash_memory); }
inline int LongTermMemoryConfig::max_number_of_flash_memory() const { return inworld_LongTermMemoryConfig_max_number_of_flash_memory_get(swig_self()); }
inline void LongTermMemoryConfig::max_number_of_topics(int max_number_of_topics) { inworld_LongTermMemoryConfig_max_number_of_topics_set(swig_self(), max_number_of_topics); }
inline int LongTermMemoryConfig::max_number_of_topics() const { return inworld_LongTermMemoryConfig_max_number_of_topics_get(swig_self()); }
inline void LongTermMemoryConfig::text_generation_config(TextGenerationConfig * text_generation_config) { inworld_LongTermMemoryConfig_text_generation_config_set(swig_self(), text_generation_config->swig_self()); }
inline TextGenerationConfig * LongTermMemoryConfig::text_generation_config() const {
  auto swig_cres = inworld_LongTermMemoryConfig_text_generation_config_get(swig_self());
  return swig_cres ? new TextGenerationConfig(swig_cres, false) : nullptr;
}
inline LongTermMemoryConfig::LongTermMemoryConfig() : LongTermMemoryConfig{inworld_LongTermMemoryConfig_new()} {}
inline LongTermMemoryConfig::LongTermMemoryConfig(LongTermMemoryConfig const & other) : LongTermMemoryConfig{inworld_LongTermMemoryConfig_copy(other.swig_self())} {}
inline void MemoryUpdateConfig::rolling_summary_config(optional_RollingSummaryConfig * rolling_summary_config) { inworld_MemoryUpdateConfig_rolling_summary_config_set(swig_self(), rolling_summary_config->swig_self()); }
inline optional_RollingSummaryConfig * MemoryUpdateConfig::rolling_summary_config() const {
  auto swig_cres = inworld_MemoryUpdateConfig_rolling_summary_config_get(swig_self());
  return swig_cres ? new optional_RollingSummaryConfig(swig_cres, false) : nullptr;
}
inline void MemoryUpdateConfig::flash_memory_config(optional_FlashMemoryConfig * flash_memory_config) { inworld_MemoryUpdateConfig_flash_memory_config_set(swig_self(), flash_memory_config->swig_self()); }
inline optional_FlashMemoryConfig * MemoryUpdateConfig::flash_memory_config() const {
  auto swig_cres = inworld_MemoryUpdateConfig_flash_memory_config_get(swig_self());
  return swig_cres ? new optional_FlashMemoryConfig(swig_cres, false) : nullptr;
}
inline void MemoryUpdateConfig::long_term_memory_config(optional_LongTermMemoryConfig * long_term_memory_config) { inworld_MemoryUpdateConfig_long_term_memory_config_set(swig_self(), long_term_memory_config->swig_self()); }
inline optional_LongTermMemoryConfig * MemoryUpdateConfig::long_term_memory_config() const {
  auto swig_cres = inworld_MemoryUpdateConfig_long_term_memory_config_get(swig_self());
  return swig_cres ? new optional_LongTermMemoryConfig(swig_cres, false) : nullptr;
}
inline MemoryUpdateConfig::MemoryUpdateConfig() : MemoryUpdateConfig{inworld_MemoryUpdateConfig_new()} {}
inline MemoryUpdateConfig::MemoryUpdateConfig(MemoryUpdateConfig const & other) : MemoryUpdateConfig{inworld_MemoryUpdateConfig_copy(other.swig_self())} {}
inline bool MemoryInterface::is_valid() const { return inworld_MemoryInterface_is_valid(swig_self()); }
inline StatusOr_vector_string MemoryInterface::GetMemory(vector_Event const & event_history, MemorySnapshot const & arg3, RetrievalConfig const & arg4, bool arg5) const {
  auto swig_cres = inworld_MemoryInterface_GetMemory_rcstd_vector_Sl_inworld_Event_Sg__rcinworld_MemorySnapshot_rcinworld_RetrievalConfig_b(swig_self(), event_history.swig_self(), arg3.swig_self(), arg4.swig_self(), arg5);
  return StatusOr_vector_string{swig_cres, true};
}
inline StatusOr_vector_string MemoryInterface::GetMemory(vector_Event const & event_history, MemorySnapshot const & arg3, RetrievalConfig const & arg4) const {
  auto swig_cres = inworld_MemoryInterface_GetMemory_rcstd_vector_Sl_inworld_Event_Sg__rcinworld_MemorySnapshot_rcinworld_RetrievalConfig(swig_self(), event_history.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_vector_string{swig_cres, true};
}
inline StatusOr_MemorySnapshot MemoryInterface::UpdateMemory(vector_Event const & event_history, MemorySnapshot const & arg3) const {
  auto swig_cres = inworld_MemoryInterface_UpdateMemory(swig_self(), event_history.swig_self(), arg3.swig_self());
  return StatusOr_MemorySnapshot{swig_cres, true};
}
inline StatusOr_MemoryInterface MemoryFactory::CreateMemory(LLMInterface const& llm, TextEmbedderInterface const& arg3, RollingSummaryConfig & arg4, FlashMemoryConfig & arg5, LongTermMemoryConfig & arg6, RetrievalConfig & arg7, bool arg8) const {
  auto swig_cres = inworld_MemoryFactory_CreateMemory(swig_self(), llm.swig_self(), arg3.swig_self(), arg4.swig_self(), arg5.swig_self(), arg6.swig_self(), arg7.swig_self(), arg8);
  return StatusOr_MemoryInterface{swig_cres, true};
}
inline MemoryFactory::MemoryFactory() : MemoryFactory{inworld_MemoryFactory_new()} {}
inline MemoryFactory::MemoryFactory(MemoryFactory const & other) : MemoryFactory{inworld_MemoryFactory_copy(other.swig_self())} {}
inline StatusOr_vector_CompiledIntent IntentCompilerInterface::CompileIntents(vector_Intent const & intents) const {
  auto swig_cres = inworld_IntentCompilerInterface_CompileIntents(swig_self(), intents.swig_self());
  return StatusOr_vector_CompiledIntent{swig_cres, true};
}
inline bool IntentCompilerInterface::is_valid() const { return inworld_IntentCompilerInterface_is_valid(swig_self()); }
inline StatusOr_IntentCompilerInterface IntentCompilerFactory::CreateIntentCompiler(TextEmbedderInterface const& embedder) const {
  auto swig_cres = inworld_IntentCompilerFactory_CreateIntentCompiler_std_shared_ptr_Sl_inworld_TextEmbedderInterface_SS_const_Sg_(swig_self(), embedder.swig_self());
  return StatusOr_IntentCompilerInterface{swig_cres, true};
}
inline StatusOr_IntentCompilerInterface IntentCompilerFactory::CreateIntentCompiler() const {
  auto swig_cres = inworld_IntentCompilerFactory_CreateIntentCompiler(swig_self());
  return StatusOr_IntentCompilerInterface{swig_cres, true};
}
inline IntentCompilerFactory::IntentCompilerFactory() : IntentCompilerFactory{inworld_IntentCompilerFactory_new()} {}
inline IntentCompilerFactory::IntentCompilerFactory(IntentCompilerFactory const & other) : IntentCompilerFactory{inworld_IntentCompilerFactory_copy(other.swig_self())} {}
inline optional_LlmMatcherConfig::optional_LlmMatcherConfig() : optional_LlmMatcherConfig{inworld_optional_LlmMatcherConfig_new()} {}
inline optional_LlmMatcherConfig::optional_LlmMatcherConfig(LlmMatcherConfig const & value) : optional_LlmMatcherConfig{inworld_optional_LlmMatcherConfig_new_rcinworld_LlmMatcherConfig(value.swig_self())} {}
inline optional_LlmMatcherConfig::optional_LlmMatcherConfig(optional_LlmMatcherConfig const & other) : optional_LlmMatcherConfig{inworld_optional_LlmMatcherConfig_copy(other.swig_self())} {}
inline bool optional_LlmMatcherConfig::has_value() const { return inworld_optional_LlmMatcherConfig_has_value(swig_self()); }
inline LlmMatcherConfig optional_LlmMatcherConfig::value() {
  auto swig_cres = inworld_optional_LlmMatcherConfig_value(swig_self());
  return LlmMatcherConfig{swig_cres, false};
}
inline LlmMatcherConfig optional_LlmMatcherConfig::value() const {
  auto swig_cres = inworld_optional_LlmMatcherConfig_valueConst(swig_self());
  return LlmMatcherConfig{swig_cres, false};
}
inline LlmMatcherConfig optional_LlmMatcherConfig::value_or(LlmMatcherConfig const & default_value) const {
  auto swig_cres = inworld_optional_LlmMatcherConfig_value_or(swig_self(), default_value.swig_self());
  return LlmMatcherConfig{swig_cres, true};
}
inline void optional_LlmMatcherConfig::reset() { inworld_optional_LlmMatcherConfig_reset(swig_self()); }
inline LlmMatcherConfig optional_LlmMatcherConfig::operator *() {
  auto swig_cres = inworld_optional_LlmMatcherConfig_get(swig_self());
  return LlmMatcherConfig{swig_cres, false};
}
inline LlmMatcherConfig optional_LlmMatcherConfig::operator *() const {
  auto swig_cres = inworld_optional_LlmMatcherConfig_getConst(swig_self());
  return LlmMatcherConfig{swig_cres, false};
}
inline LlmMatcherConfig optional_LlmMatcherConfig::get_value() {
  auto swig_cres = inworld_optional_LlmMatcherConfig_get_value(swig_self());
  return LlmMatcherConfig{swig_cres, false};
}
inline void optional_LlmMatcherConfig::set_value(LlmMatcherConfig & t) { inworld_optional_LlmMatcherConfig_set_value(swig_self(), t.swig_self()); }
inline optional_TextEmbedderInterface::optional_TextEmbedderInterface() : optional_TextEmbedderInterface{inworld_optional_TextEmbedderInterface_new()} {}
inline optional_TextEmbedderInterface::optional_TextEmbedderInterface(TextEmbedderInterface const& value) : optional_TextEmbedderInterface{inworld_optional_TextEmbedderInterface_new_rcstd_shared_ptr_Sl_inworld_TextEmbedderInterface_SS_const_Sg_(value.swig_self())} {}
inline optional_TextEmbedderInterface::optional_TextEmbedderInterface(optional_TextEmbedderInterface const & other) : optional_TextEmbedderInterface{inworld_optional_TextEmbedderInterface_copy(other.swig_self())} {}
inline bool optional_TextEmbedderInterface::has_value() const { return inworld_optional_TextEmbedderInterface_has_value(swig_self()); }
inline TextEmbedderInterface optional_TextEmbedderInterface::value() {
  auto swig_cres = inworld_optional_TextEmbedderInterface_value(swig_self());
  return TextEmbedderInterface{swig_cres, false};
}
inline TextEmbedderInterface optional_TextEmbedderInterface::value() const {
  auto swig_cres = inworld_optional_TextEmbedderInterface_valueConst(swig_self());
  return TextEmbedderInterface{swig_cres, false};
}
inline TextEmbedderInterface optional_TextEmbedderInterface::value_or(TextEmbedderInterface const& default_value) const {
  auto swig_cres = inworld_optional_TextEmbedderInterface_value_or(swig_self(), default_value.swig_self());
  return TextEmbedderInterface{swig_cres, true};
}
inline void optional_TextEmbedderInterface::reset() { inworld_optional_TextEmbedderInterface_reset(swig_self()); }
inline TextEmbedderInterface optional_TextEmbedderInterface::operator *() {
  auto swig_cres = inworld_optional_TextEmbedderInterface_get(swig_self());
  return TextEmbedderInterface{swig_cres, false};
}
inline TextEmbedderInterface optional_TextEmbedderInterface::operator *() const {
  auto swig_cres = inworld_optional_TextEmbedderInterface_getConst(swig_self());
  return TextEmbedderInterface{swig_cres, false};
}
inline TextEmbedderInterface optional_TextEmbedderInterface::get_value() {
  auto swig_cres = inworld_optional_TextEmbedderInterface_get_value(swig_self());
  return TextEmbedderInterface{swig_cres, false};
}
inline void optional_TextEmbedderInterface::set_value(TextEmbedderInterface const& t) { inworld_optional_TextEmbedderInterface_set_value(swig_self(), t.swig_self()); }
inline optional_EmbeddingMatcherConfig::optional_EmbeddingMatcherConfig() : optional_EmbeddingMatcherConfig{inworld_optional_EmbeddingMatcherConfig_new()} {}
inline optional_EmbeddingMatcherConfig::optional_EmbeddingMatcherConfig(EmbeddingMatcherConfig const & value) : optional_EmbeddingMatcherConfig{inworld_optional_EmbeddingMatcherConfig_new_rcinworld_EmbeddingMatcherConfig(value.swig_self())} {}
inline optional_EmbeddingMatcherConfig::optional_EmbeddingMatcherConfig(optional_EmbeddingMatcherConfig const & other) : optional_EmbeddingMatcherConfig{inworld_optional_EmbeddingMatcherConfig_copy(other.swig_self())} {}
inline bool optional_EmbeddingMatcherConfig::has_value() const { return inworld_optional_EmbeddingMatcherConfig_has_value(swig_self()); }
inline EmbeddingMatcherConfig optional_EmbeddingMatcherConfig::value() {
  auto swig_cres = inworld_optional_EmbeddingMatcherConfig_value(swig_self());
  return EmbeddingMatcherConfig{swig_cres, false};
}
inline EmbeddingMatcherConfig optional_EmbeddingMatcherConfig::value() const {
  auto swig_cres = inworld_optional_EmbeddingMatcherConfig_valueConst(swig_self());
  return EmbeddingMatcherConfig{swig_cres, false};
}
inline EmbeddingMatcherConfig optional_EmbeddingMatcherConfig::value_or(EmbeddingMatcherConfig const & default_value) const {
  auto swig_cres = inworld_optional_EmbeddingMatcherConfig_value_or(swig_self(), default_value.swig_self());
  return EmbeddingMatcherConfig{swig_cres, true};
}
inline void optional_EmbeddingMatcherConfig::reset() { inworld_optional_EmbeddingMatcherConfig_reset(swig_self()); }
inline EmbeddingMatcherConfig optional_EmbeddingMatcherConfig::operator *() {
  auto swig_cres = inworld_optional_EmbeddingMatcherConfig_get(swig_self());
  return EmbeddingMatcherConfig{swig_cres, false};
}
inline EmbeddingMatcherConfig optional_EmbeddingMatcherConfig::operator *() const {
  auto swig_cres = inworld_optional_EmbeddingMatcherConfig_getConst(swig_self());
  return EmbeddingMatcherConfig{swig_cres, false};
}
inline EmbeddingMatcherConfig optional_EmbeddingMatcherConfig::get_value() {
  auto swig_cres = inworld_optional_EmbeddingMatcherConfig_get_value(swig_self());
  return EmbeddingMatcherConfig{swig_cres, false};
}
inline void optional_EmbeddingMatcherConfig::set_value(EmbeddingMatcherConfig & t) { inworld_optional_EmbeddingMatcherConfig_set_value(swig_self(), t.swig_self()); }
inline void IntentMatch::intent_name(std::string const& intent_name) { inworld_IntentMatch_intent_name_set(swig_self(), (&intent_name)->c_str()); }
inline std::string IntentMatch::intent_name() const {
  auto swig_cres = inworld_IntentMatch_intent_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void IntentMatch::score(float score) { inworld_IntentMatch_score_set(swig_self(), score); }
inline float IntentMatch::score() const { return inworld_IntentMatch_score_get(swig_self()); }
inline IntentMatch::IntentMatch() : IntentMatch{inworld_IntentMatch_new()} {}
inline IntentMatch::IntentMatch(IntentMatch const & other) : IntentMatch{inworld_IntentMatch_copy(other.swig_self())} {}
inline void EmbeddingMatcherConfig::similarity_threshold(float similarity_threshold) { inworld_EmbeddingMatcherConfig_similarity_threshold_set(swig_self(), similarity_threshold); }
inline float EmbeddingMatcherConfig::similarity_threshold() const { return inworld_EmbeddingMatcherConfig_similarity_threshold_get(swig_self()); }
inline EmbeddingMatcherConfig::EmbeddingMatcherConfig() : EmbeddingMatcherConfig{inworld_EmbeddingMatcherConfig_new()} {}
inline EmbeddingMatcherConfig::EmbeddingMatcherConfig(EmbeddingMatcherConfig const & other) : EmbeddingMatcherConfig{inworld_EmbeddingMatcherConfig_copy(other.swig_self())} {}
inline void LlmMatcherConfig::generation_config(TextGenerationConfig * generation_config) { inworld_LlmMatcherConfig_generation_config_set(swig_self(), generation_config->swig_self()); }
inline TextGenerationConfig * LlmMatcherConfig::generation_config() const {
  auto swig_cres = inworld_LlmMatcherConfig_generation_config_get(swig_self());
  return swig_cres ? new TextGenerationConfig(swig_cres, false) : nullptr;
}
inline void LlmMatcherConfig::prompt_template(std::string const& prompt_template) { inworld_LlmMatcherConfig_prompt_template_set(swig_self(), (&prompt_template)->c_str()); }
inline std::string LlmMatcherConfig::prompt_template() const {
  auto swig_cres = inworld_LlmMatcherConfig_prompt_template_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LlmMatcherConfig::embedding_similarity_threshold(optional_float * embedding_similarity_threshold) { inworld_LlmMatcherConfig_embedding_similarity_threshold_set(swig_self(), embedding_similarity_threshold->swig_self()); }
inline optional_float * LlmMatcherConfig::embedding_similarity_threshold() const {
  auto swig_cres = inworld_LlmMatcherConfig_embedding_similarity_threshold_get(swig_self());
  return swig_cres ? new optional_float(swig_cres, false) : nullptr;
}
inline void LlmMatcherConfig::max_embedding_matches_for_llm(optional_int * max_embedding_matches_for_llm) { inworld_LlmMatcherConfig_max_embedding_matches_for_llm_set(swig_self(), max_embedding_matches_for_llm->swig_self()); }
inline optional_int * LlmMatcherConfig::max_embedding_matches_for_llm() const {
  auto swig_cres = inworld_LlmMatcherConfig_max_embedding_matches_for_llm_get(swig_self());
  return swig_cres ? new optional_int(swig_cres, false) : nullptr;
}
inline LlmMatcherConfig::LlmMatcherConfig() : LlmMatcherConfig{inworld_LlmMatcherConfig_new()} {}
inline LlmMatcherConfig::LlmMatcherConfig(LlmMatcherConfig const & other) : LlmMatcherConfig{inworld_LlmMatcherConfig_copy(other.swig_self())} {}
inline void IntentMatcherConfig::embedding(optional_EmbeddingMatcherConfig * embedding) { inworld_IntentMatcherConfig_embedding_set(swig_self(), embedding->swig_self()); }
inline optional_EmbeddingMatcherConfig * IntentMatcherConfig::embedding() const {
  auto swig_cres = inworld_IntentMatcherConfig_embedding_get(swig_self());
  return swig_cres ? new optional_EmbeddingMatcherConfig(swig_cres, false) : nullptr;
}
inline void IntentMatcherConfig::llm(optional_LlmMatcherConfig * llm) { inworld_IntentMatcherConfig_llm_set(swig_self(), llm->swig_self()); }
inline optional_LlmMatcherConfig * IntentMatcherConfig::llm() const {
  auto swig_cres = inworld_IntentMatcherConfig_llm_get(swig_self());
  return swig_cres ? new optional_LlmMatcherConfig(swig_cres, false) : nullptr;
}
inline void IntentMatcherConfig::top_n_intents(int top_n_intents) { inworld_IntentMatcherConfig_top_n_intents_set(swig_self(), top_n_intents); }
inline int IntentMatcherConfig::top_n_intents() const { return inworld_IntentMatcherConfig_top_n_intents_get(swig_self()); }
inline IntentMatcherConfig::IntentMatcherConfig() : IntentMatcherConfig{inworld_IntentMatcherConfig_new()} {}
inline IntentMatcherConfig::IntentMatcherConfig(IntentMatcherConfig const & other) : IntentMatcherConfig{inworld_IntentMatcherConfig_copy(other.swig_self())} {}
inline bool IntentMatcherInterface::is_valid() const { return inworld_IntentMatcherInterface_is_valid(swig_self()); }
inline StatusOr_vector_IntentMatch IntentMatcherInterface::MatchIntents(std::string const& input) const {
  auto swig_cres = inworld_IntentMatcherInterface_MatchIntents(swig_self(), (&input)->c_str());
  return StatusOr_vector_IntentMatch{swig_cres, true};
}
inline void IntentMatcherCreationConfig::matcher_config(IntentMatcherConfig * matcher_config) { inworld_IntentMatcherCreationConfig_matcher_config_set(swig_self(), matcher_config->swig_self()); }
inline IntentMatcherConfig * IntentMatcherCreationConfig::matcher_config() const {
  auto swig_cres = inworld_IntentMatcherCreationConfig_matcher_config_get(swig_self());
  return swig_cres ? new IntentMatcherConfig(swig_cres, false) : nullptr;
}
inline void IntentMatcherCreationConfig::compiled_intents(vector_CompiledIntent * compiled_intents) { inworld_IntentMatcherCreationConfig_compiled_intents_set(swig_self(), compiled_intents->swig_self()); }
inline vector_CompiledIntent * IntentMatcherCreationConfig::compiled_intents() const {
  auto swig_cres = inworld_IntentMatcherCreationConfig_compiled_intents_get(swig_self());
  return swig_cres ? new vector_CompiledIntent(swig_cres, false) : nullptr;
}
inline IntentMatcherCreationConfig::IntentMatcherCreationConfig() : IntentMatcherCreationConfig{inworld_IntentMatcherCreationConfig_new()} {}
inline IntentMatcherCreationConfig::IntentMatcherCreationConfig(IntentMatcherCreationConfig const & other) : IntentMatcherCreationConfig{inworld_IntentMatcherCreationConfig_copy(other.swig_self())} {}
inline StatusOr_IntentMatcherInterface IntentMatcherFactory::CreateIntentMatcher(TextEmbedderInterface const& embedder, LLMInterface const& arg3, IntentMatcherCreationConfig const & arg4) const {
  auto swig_cres = inworld_IntentMatcherFactory_CreateIntentMatcher_std_shared_ptr_Sl_inworld_TextEmbedderInterface_SS_const_Sg__std_shared_ptr_Sl_inworld_LLMInterface_SS_const_Sg__rcinworld_IntentMatcherCreationConfig(swig_self(), embedder.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_IntentMatcherInterface{swig_cres, true};
}
inline StatusOr_IntentMatcherInterface IntentMatcherFactory::CreateIntentMatcher(TextEmbedderInterface const& embedder, IntentMatcherCreationConfig const & arg3) const {
  auto swig_cres = inworld_IntentMatcherFactory_CreateIntentMatcher_std_shared_ptr_Sl_inworld_TextEmbedderInterface_SS_const_Sg__rcinworld_IntentMatcherCreationConfig(swig_self(), embedder.swig_self(), arg3.swig_self());
  return StatusOr_IntentMatcherInterface{swig_cres, true};
}
inline StatusOr_IntentMatcherInterface IntentMatcherFactory::CreateIntentMatcher(LLMInterface const& llm_client, IntentMatcherCreationConfig const & arg3) const {
  auto swig_cres = inworld_IntentMatcherFactory_CreateIntentMatcher_std_shared_ptr_Sl_inworld_LLMInterface_SS_const_Sg__rcinworld_IntentMatcherCreationConfig(swig_self(), llm_client.swig_self(), arg3.swig_self());
  return StatusOr_IntentMatcherInterface{swig_cres, true};
}
inline IntentMatcherFactory::IntentMatcherFactory() : IntentMatcherFactory{inworld_IntentMatcherFactory_new()} {}
inline IntentMatcherFactory::IntentMatcherFactory(IntentMatcherFactory const & other) : IntentMatcherFactory{inworld_IntentMatcherFactory_copy(other.swig_self())} {}
inline void KeywordGroup::name(std::string const& name) { inworld_KeywordGroup_name_set(swig_self(), (&name)->c_str()); }
inline std::string KeywordGroup::name() const {
  auto swig_cres = inworld_KeywordGroup_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void KeywordGroup::keywords(vector_string * keywords) { inworld_KeywordGroup_keywords_set(swig_self(), keywords->swig_self()); }
inline vector_string * KeywordGroup::keywords() const {
  auto swig_cres = inworld_KeywordGroup_keywords_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline KeywordGroup::KeywordGroup() : KeywordGroup{inworld_KeywordGroup_new()} {}
inline KeywordGroup::KeywordGroup(KeywordGroup const & other) : KeywordGroup{inworld_KeywordGroup_copy(other.swig_self())} {}
inline void KeywordMatch::group_name(std::string const& group_name) { inworld_KeywordMatch_group_name_set(swig_self(), (&group_name)->c_str()); }
inline std::string KeywordMatch::group_name() const {
  auto swig_cres = inworld_KeywordMatch_group_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void KeywordMatch::keyword(std::string const& keyword) { inworld_KeywordMatch_keyword_set(swig_self(), (&keyword)->c_str()); }
inline std::string KeywordMatch::keyword() const {
  auto swig_cres = inworld_KeywordMatch_keyword_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline KeywordMatch::KeywordMatch() : KeywordMatch{inworld_KeywordMatch_new()} {}
inline KeywordMatch::KeywordMatch(KeywordMatch const & other) : KeywordMatch{inworld_KeywordMatch_copy(other.swig_self())} {}
inline void KeywordMatcherResponse::matches(vector_KeywordMatch * matches) { inworld_KeywordMatcherResponse_matches_set(swig_self(), matches->swig_self()); }
inline vector_KeywordMatch * KeywordMatcherResponse::matches() const {
  auto swig_cres = inworld_KeywordMatcherResponse_matches_get(swig_self());
  return swig_cres ? new vector_KeywordMatch(swig_cres, false) : nullptr;
}
inline bool KeywordMatcherResponse::HasMatches() const { return inworld_KeywordMatcherResponse_HasMatches(swig_self()); }
inline KeywordMatcherResponse::KeywordMatcherResponse() : KeywordMatcherResponse{inworld_KeywordMatcherResponse_new()} {}
inline KeywordMatcherResponse::KeywordMatcherResponse(KeywordMatcherResponse const & other) : KeywordMatcherResponse{inworld_KeywordMatcherResponse_copy(other.swig_self())} {}
inline bool KeywordMatcherInterface::is_valid() const { return inworld_KeywordMatcherInterface_is_valid(swig_self()); }
inline StatusOr_KeywordMatcherResponse KeywordMatcherInterface::MatchKeywords(std::string const& input) const {
  auto swig_cres = inworld_KeywordMatcherInterface_MatchKeywords(swig_self(), (&input)->c_str());
  return StatusOr_KeywordMatcherResponse{swig_cres, true};
}
inline StatusOr_KeywordMatcherInterface KeywordMatcherFactory::CreateKeywordMatcher(vector_KeywordGroup const & keyword_groups) const {
  auto swig_cres = inworld_KeywordMatcherFactory_CreateKeywordMatcher(swig_self(), keyword_groups.swig_self());
  return StatusOr_KeywordMatcherInterface{swig_cres, true};
}
inline KeywordMatcherFactory::KeywordMatcherFactory() : KeywordMatcherFactory{inworld_KeywordMatcherFactory_new()} {}
inline KeywordMatcherFactory::KeywordMatcherFactory(KeywordMatcherFactory const & other) : KeywordMatcherFactory{inworld_KeywordMatcherFactory_copy(other.swig_self())} {}
inline void DictionaryRule::name(std::string const& name) { inworld_DictionaryRule_name_set(swig_self(), (&name)->c_str()); }
inline std::string DictionaryRule::name() const {
  auto swig_cres = inworld_DictionaryRule_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void DictionaryRule::display_name(std::string const& display_name) { inworld_DictionaryRule_display_name_set(swig_self(), (&display_name)->c_str()); }
inline std::string DictionaryRule::display_name() const {
  auto swig_cres = inworld_DictionaryRule_display_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void DictionaryRule::synonyms(vector_string * synonyms) { inworld_DictionaryRule_synonyms_set(swig_self(), synonyms->swig_self()); }
inline vector_string * DictionaryRule::synonyms() const {
  auto swig_cres = inworld_DictionaryRule_synonyms_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline DictionaryRule::DictionaryRule() : DictionaryRule{inworld_DictionaryRule_new()} {}
inline DictionaryRule::DictionaryRule(DictionaryRule const & other) : DictionaryRule{inworld_DictionaryRule_copy(other.swig_self())} {}
inline void Entity::name(std::string const& name) { inworld_Entity_name_set(swig_self(), (&name)->c_str()); }
inline std::string Entity::name() const {
  auto swig_cres = inworld_Entity_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Entity::rules(vector_DictionaryRule * rules) { inworld_Entity_rules_set(swig_self(), rules->swig_self()); }
inline vector_DictionaryRule * Entity::rules() const {
  auto swig_cres = inworld_Entity_rules_get(swig_self());
  return swig_cres ? new vector_DictionaryRule(swig_cres, false) : nullptr;
}
inline Entity::Entity() : Entity{inworld_Entity_new()} {}
inline Entity::Entity(Entity const & other) : Entity{inworld_Entity_copy(other.swig_self())} {}
inline void EntityMatch::entity_name(std::string const& entity_name) { inworld_EntityMatch_entity_name_set(swig_self(), (&entity_name)->c_str()); }
inline std::string EntityMatch::entity_name() const {
  auto swig_cres = inworld_EntityMatch_entity_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void EntityMatch::rule_name(std::string const& rule_name) { inworld_EntityMatch_rule_name_set(swig_self(), (&rule_name)->c_str()); }
inline std::string EntityMatch::rule_name() const {
  auto swig_cres = inworld_EntityMatch_rule_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void EntityMatch::text(std::string const& text) { inworld_EntityMatch_text_set(swig_self(), (&text)->c_str()); }
inline std::string EntityMatch::text() const {
  auto swig_cres = inworld_EntityMatch_text_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline EntityMatch::EntityMatch() : EntityMatch{inworld_EntityMatch_new()} {}
inline EntityMatch::EntityMatch(EntityMatch const & other) : EntityMatch{inworld_EntityMatch_copy(other.swig_self())} {}
inline StatusOr_vector_EntityMatch NERInterface::ExtractEntities(std::string const& text) const {
  auto swig_cres = inworld_NERInterface_ExtractEntities(swig_self(), (&text)->c_str());
  return StatusOr_vector_EntityMatch{swig_cres, true};
}
inline bool NERInterface::is_valid() const { return inworld_NERInterface_is_valid(swig_self()); }
inline void NERCreationConfig::entities(vector_Entity * entities) { inworld_NERCreationConfig_entities_set(swig_self(), entities->swig_self()); }
inline vector_Entity * NERCreationConfig::entities() const {
  auto swig_cres = inworld_NERCreationConfig_entities_get(swig_self());
  return swig_cres ? new vector_Entity(swig_cres, false) : nullptr;
}
inline NERCreationConfig::NERCreationConfig() : NERCreationConfig{inworld_NERCreationConfig_new()} {}
inline NERCreationConfig::NERCreationConfig(NERCreationConfig const & other) : NERCreationConfig{inworld_NERCreationConfig_copy(other.swig_self())} {}
inline StatusOr_NERInterface NERFactory::inworld_inworld_NERFactory_CreateNER__SWIG(NERCreationConfig const & config) {
  auto swig_cres = inworld_NERFactory_CreateNER(config.swig_self());
  return StatusOr_NERInterface{swig_cres, true};
}
inline NERFactory::NERFactory() : NERFactory{inworld_NERFactory_new()} {}
inline NERFactory::NERFactory(NERFactory const & other) : NERFactory{inworld_NERFactory_copy(other.swig_self())} {}
inline VectorClassThreshold::VectorClassThreshold() : VectorClassThreshold{inworld_VectorClassThreshold_new()} {}
inline VectorClassThreshold::VectorClassThreshold(VectorClassThreshold const & other) : VectorClassThreshold{inworld_VectorClassThreshold_copy(other.swig_self())} {}
inline size_t VectorClassThreshold::size() const { return inworld_VectorClassThreshold_size(swig_self()); }
inline size_t VectorClassThreshold::capacity() const { return inworld_VectorClassThreshold_capacity(swig_self()); }
inline void VectorClassThreshold::reserve(size_t n) { inworld_VectorClassThreshold_reserve(swig_self(), n); }
inline bool VectorClassThreshold::empty() const { return inworld_VectorClassThreshold_empty(swig_self()); }
inline void VectorClassThreshold::clear() { inworld_VectorClassThreshold_clear(swig_self()); }
inline void VectorClassThreshold::push_back(ClassThreshold const & x) { inworld_VectorClassThreshold_push_back(swig_self(), x.swig_self()); }
inline ClassThreshold VectorClassThreshold::get(int i) {
  auto swig_cres = inworld_VectorClassThreshold_get(swig_self(), i);
  return ClassThreshold{swig_cres, false};
}
inline void VectorClassThreshold::set(int i, ClassThreshold const & arg3) { inworld_VectorClassThreshold_set(swig_self(), i, arg3.swig_self()); }
inline TextClassifierResponseStatusOr::TextClassifierResponseStatusOr() : TextClassifierResponseStatusOr{inworld_TextClassifierResponseStatusOr_new()} {}
inline TextClassifierResponseStatusOr::TextClassifierResponseStatusOr(TextClassifierResponse const & value) : TextClassifierResponseStatusOr{inworld_TextClassifierResponseStatusOr_new_rcinworld_TextClassifierResponse(value.swig_self())} {}
inline TextClassifierResponseStatusOr::TextClassifierResponseStatusOr(Status const & status) : TextClassifierResponseStatusOr{inworld_TextClassifierResponseStatusOr_new_rcabsl_Status(status.swig_self())} {}
inline bool TextClassifierResponseStatusOr::ok() const { return inworld_TextClassifierResponseStatusOr_ok(swig_self()); }
inline Status TextClassifierResponseStatusOr::status() const {
  auto swig_cres = inworld_TextClassifierResponseStatusOr_status(swig_self());
  return Status{swig_cres, false};
}
inline TextClassifierResponse TextClassifierResponseStatusOr::value() const {
  auto swig_cres = inworld_TextClassifierResponseStatusOr_value(swig_self());
  return TextClassifierResponse{swig_cres, true};
}
inline TextClassifierResponseStatusOr::TextClassifierResponseStatusOr(TextClassifierResponseStatusOr const & other) : TextClassifierResponseStatusOr{inworld_TextClassifierResponseStatusOr_copy(other.swig_self())} {}
inline void ClassThreshold::class_label(std::string const& class_label) { inworld_ClassThreshold_class_label_set(swig_self(), (&class_label)->c_str()); }
inline std::string ClassThreshold::class_label() const {
  auto swig_cres = inworld_ClassThreshold_class_label_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void ClassThreshold::threshold(float threshold) { inworld_ClassThreshold_threshold_set(swig_self(), threshold); }
inline float ClassThreshold::threshold() const { return inworld_ClassThreshold_threshold_get(swig_self()); }
inline ClassThreshold::ClassThreshold() : ClassThreshold{inworld_ClassThreshold_new()} {}
inline ClassThreshold::ClassThreshold(ClassThreshold const & other) : ClassThreshold{inworld_ClassThreshold_copy(other.swig_self())} {}
inline void TextClassifierConfig::classes(VectorClassThreshold * classes) { inworld_TextClassifierConfig_classes_set(swig_self(), classes->swig_self()); }
inline VectorClassThreshold * TextClassifierConfig::classes() const {
  auto swig_cres = inworld_TextClassifierConfig_classes_get(swig_self());
  return swig_cres ? new VectorClassThreshold(swig_cres, false) : nullptr;
}
inline TextClassifierConfig::TextClassifierConfig() : TextClassifierConfig{inworld_TextClassifierConfig_new()} {}
inline TextClassifierConfig::TextClassifierConfig(TextClassifierConfig const & other) : TextClassifierConfig{inworld_TextClassifierConfig_copy(other.swig_self())} {}
inline void TextClassifierResponse::classes(vector_string * classes) { inworld_TextClassifierResponse_classes_set(swig_self(), classes->swig_self()); }
inline vector_string * TextClassifierResponse::classes() const {
  auto swig_cres = inworld_TextClassifierResponse_classes_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline bool TextClassifierResponse::HasResults() const { return inworld_TextClassifierResponse_HasResults(swig_self()); }
inline TextClassifierResponse::TextClassifierResponse() : TextClassifierResponse{inworld_TextClassifierResponse_new()} {}
inline TextClassifierResponse::TextClassifierResponse(TextClassifierResponse const & other) : TextClassifierResponse{inworld_TextClassifierResponse_copy(other.swig_self())} {}
inline TextClassifierResponseStatusOr TextClassifierInterface::ClassifyText(std::string const& input) const {
  auto swig_cres = inworld_TextClassifierInterface_ClassifyText_rcstd_string(swig_self(), (&input)->c_str());
  return TextClassifierResponseStatusOr{swig_cres, true};
}
inline TextClassifierResponseStatusOr TextClassifierInterface::ClassifyText(std::string const& input, TextClassifierConfig const & arg3) const {
  auto swig_cres = inworld_TextClassifierInterface_ClassifyText_rcstd_string_rcinworld_TextClassifierConfig(swig_self(), (&input)->c_str(), arg3.swig_self());
  return TextClassifierResponseStatusOr{swig_cres, true};
}
inline TextClassifierInterfaceSharedPtrStatusOr::TextClassifierInterfaceSharedPtrStatusOr() : TextClassifierInterfaceSharedPtrStatusOr{inworld_TextClassifierInterfaceSharedPtrStatusOr_new()} {}
inline TextClassifierInterfaceSharedPtrStatusOr::TextClassifierInterfaceSharedPtrStatusOr(TextClassifierInterface const& value) : TextClassifierInterfaceSharedPtrStatusOr{inworld_TextClassifierInterfaceSharedPtrStatusOr_new_rcstd_shared_ptr_Sl_inworld_TextClassifierInterface_Sg_(value.swig_self())} {}
inline TextClassifierInterfaceSharedPtrStatusOr::TextClassifierInterfaceSharedPtrStatusOr(Status const & status) : TextClassifierInterfaceSharedPtrStatusOr{inworld_TextClassifierInterfaceSharedPtrStatusOr_new_rcabsl_Status(status.swig_self())} {}
inline bool TextClassifierInterfaceSharedPtrStatusOr::ok() const { return inworld_TextClassifierInterfaceSharedPtrStatusOr_ok(swig_self()); }
inline Status TextClassifierInterfaceSharedPtrStatusOr::status() const {
  auto swig_cres = inworld_TextClassifierInterfaceSharedPtrStatusOr_status(swig_self());
  return Status{swig_cres, false};
}
inline TextClassifierInterface TextClassifierInterfaceSharedPtrStatusOr::value() const {
  auto swig_cres = inworld_TextClassifierInterfaceSharedPtrStatusOr_value(swig_self());
  return TextClassifierInterface{swig_cres, true};
}
inline TextClassifierInterfaceSharedPtrStatusOr::TextClassifierInterfaceSharedPtrStatusOr(TextClassifierInterfaceSharedPtrStatusOr const & other) : TextClassifierInterfaceSharedPtrStatusOr{inworld_TextClassifierInterfaceSharedPtrStatusOr_copy(other.swig_self())} {}
inline void TextClassifierCreationConfig::model_weights_path(std::string const& model_weights_path) { inworld_TextClassifierCreationConfig_model_weights_path_set(swig_self(), (&model_weights_path)->c_str()); }
inline std::string TextClassifierCreationConfig::model_weights_path() const {
  auto swig_cres = inworld_TextClassifierCreationConfig_model_weights_path_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void TextClassifierCreationConfig::supported_classes(vector_string * supported_classes) { inworld_TextClassifierCreationConfig_supported_classes_set(swig_self(), supported_classes->swig_self()); }
inline vector_string * TextClassifierCreationConfig::supported_classes() const {
  auto swig_cres = inworld_TextClassifierCreationConfig_supported_classes_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline TextClassifierCreationConfig::TextClassifierCreationConfig() : TextClassifierCreationConfig{inworld_TextClassifierCreationConfig_new()} {}
inline TextClassifierCreationConfig::TextClassifierCreationConfig(TextClassifierCreationConfig const & other) : TextClassifierCreationConfig{inworld_TextClassifierCreationConfig_copy(other.swig_self())} {}
inline TextClassifierInterfaceSharedPtrStatusOr TextClassifierFactory::CreateTextClassifier(TextEmbedderInterface const& embedder, TextClassifierCreationConfig const & arg3) const {
  auto swig_cres = inworld_TextClassifierFactory_CreateTextClassifier(swig_self(), embedder.swig_self(), arg3.swig_self());
  return TextClassifierInterfaceSharedPtrStatusOr{swig_cres, true};
}
inline TextClassifierFactory::TextClassifierFactory() : TextClassifierFactory{inworld_TextClassifierFactory_new()} {}
inline TextClassifierFactory::TextClassifierFactory(TextClassifierFactory const & other) : TextClassifierFactory{inworld_TextClassifierFactory_copy(other.swig_self())} {}
inline void TopicThreshold::topic_name(TopicName topic_name) { inworld_TopicThreshold_topic_name_set(swig_self(), (inworld_TopicName)topic_name); }
inline TopicName TopicThreshold::topic_name() const {
  auto swig_cres = inworld_TopicThreshold_topic_name_get(swig_self());
  return (TopicName)swig_cres;
}
inline void TopicThreshold::threshold(float threshold) { inworld_TopicThreshold_threshold_set(swig_self(), threshold); }
inline float TopicThreshold::threshold() const { return inworld_TopicThreshold_threshold_get(swig_self()); }
inline TopicThreshold::TopicThreshold() : TopicThreshold{inworld_TopicThreshold_new()} {}
inline TopicThreshold::TopicThreshold(TopicThreshold const & other) : TopicThreshold{inworld_TopicThreshold_copy(other.swig_self())} {}
inline void SafetyConfig::forbidden_topics(vector_TopicThreshold * forbidden_topics) { inworld_SafetyConfig_forbidden_topics_set(swig_self(), forbidden_topics->swig_self()); }
inline vector_TopicThreshold * SafetyConfig::forbidden_topics() const {
  auto swig_cres = inworld_SafetyConfig_forbidden_topics_get(swig_self());
  return swig_cres ? new vector_TopicThreshold(swig_cres, false) : nullptr;
}
inline SafetyConfig::SafetyConfig() : SafetyConfig{inworld_SafetyConfig_new()} {}
inline SafetyConfig::SafetyConfig(SafetyConfig const & other) : SafetyConfig{inworld_SafetyConfig_copy(other.swig_self())} {}
inline void DetectedTopic::topic_name(TopicName topic_name) { inworld_DetectedTopic_topic_name_set(swig_self(), (inworld_TopicName)topic_name); }
inline TopicName DetectedTopic::topic_name() const {
  auto swig_cres = inworld_DetectedTopic_topic_name_get(swig_self());
  return (TopicName)swig_cres;
}
inline void DetectedTopic::confidence(float confidence) { inworld_DetectedTopic_confidence_set(swig_self(), confidence); }
inline float DetectedTopic::confidence() const { return inworld_DetectedTopic_confidence_get(swig_self()); }
inline DetectedTopic::DetectedTopic() : DetectedTopic{inworld_DetectedTopic_new()} {}
inline DetectedTopic::DetectedTopic(DetectedTopic const & other) : DetectedTopic{inworld_DetectedTopic_copy(other.swig_self())} {}
inline void CheckSafetyResponse::is_safe(bool is_safe) { inworld_CheckSafetyResponse_is_safe_set(swig_self(), is_safe); }
inline bool CheckSafetyResponse::is_safe() const { return inworld_CheckSafetyResponse_is_safe_get(swig_self()); }
inline void CheckSafetyResponse::detected_topics(vector_DetectedTopic * detected_topics) { inworld_CheckSafetyResponse_detected_topics_set(swig_self(), detected_topics->swig_self()); }
inline vector_DetectedTopic * CheckSafetyResponse::detected_topics() const {
  auto swig_cres = inworld_CheckSafetyResponse_detected_topics_get(swig_self());
  return swig_cres ? new vector_DetectedTopic(swig_cres, false) : nullptr;
}
inline CheckSafetyResponse::CheckSafetyResponse() : CheckSafetyResponse{inworld_CheckSafetyResponse_new()} {}
inline CheckSafetyResponse::CheckSafetyResponse(CheckSafetyResponse const & other) : CheckSafetyResponse{inworld_CheckSafetyResponse_copy(other.swig_self())} {}
inline bool SafetyCheckerInterface::is_valid() const { return inworld_SafetyCheckerInterface_is_valid(swig_self()); }
inline StatusOr_CheckSafetyResponse SafetyCheckerInterface::CheckSafety(std::string const& input) const {
  auto swig_cres = inworld_SafetyCheckerInterface_CheckSafety_rcstd_string(swig_self(), (&input)->c_str());
  return StatusOr_CheckSafetyResponse{swig_cres, true};
}
inline StatusOr_CheckSafetyResponse SafetyCheckerInterface::CheckSafety(std::string const& input, SafetyConfig const & arg3) const {
  auto swig_cres = inworld_SafetyCheckerInterface_CheckSafety_rcstd_string_rcinworld_SafetyConfig(swig_self(), (&input)->c_str(), arg3.swig_self());
  return StatusOr_CheckSafetyResponse{swig_cres, true};
}
inline void SafetyCheckerCreationConfig::model_weights_path(std::string const& model_weights_path) { inworld_SafetyCheckerCreationConfig_model_weights_path_set(swig_self(), (&model_weights_path)->c_str()); }
inline std::string SafetyCheckerCreationConfig::model_weights_path() const {
  auto swig_cres = inworld_SafetyCheckerCreationConfig_model_weights_path_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline SafetyCheckerCreationConfig::SafetyCheckerCreationConfig() : SafetyCheckerCreationConfig{inworld_SafetyCheckerCreationConfig_new()} {}
inline SafetyCheckerCreationConfig::SafetyCheckerCreationConfig(SafetyCheckerCreationConfig const & other) : SafetyCheckerCreationConfig{inworld_SafetyCheckerCreationConfig_copy(other.swig_self())} {}
inline StatusOr_SafetyCheckerInterface SafetyCheckerFactory::CreateSafetyChecker(TextEmbedderInterface const& embedder, SafetyCheckerCreationConfig const & arg3) const {
  auto swig_cres = inworld_SafetyCheckerFactory_CreateSafetyChecker(swig_self(), embedder.swig_self(), arg3.swig_self());
  return StatusOr_SafetyCheckerInterface{swig_cres, true};
}
inline SafetyCheckerFactory::SafetyCheckerFactory() : SafetyCheckerFactory{inworld_SafetyCheckerFactory_new()} {}
inline SafetyCheckerFactory::SafetyCheckerFactory(SafetyCheckerFactory const & other) : SafetyCheckerFactory{inworld_SafetyCheckerFactory_copy(other.swig_self())} {}
inline StatusOr_EmojiRemover EmojiRemover::Create(InputStream_string const& input_stream) {
  auto swig_cres = inworld_EmojiRemover_Create(input_stream.swig_self());
  return StatusOr_EmojiRemover{swig_cres, true};
}
inline bool EmojiRemover::is_valid() const { return inworld_EmojiRemover_is_valid(swig_self()); }
inline void SentenceStreamCreationConfig::min_chunk_length(optional_int * min_chunk_length) { inworld_SentenceStreamCreationConfig_min_chunk_length_set(swig_self(), min_chunk_length->swig_self()); }
inline optional_int * SentenceStreamCreationConfig::min_chunk_length() const {
  auto swig_cres = inworld_SentenceStreamCreationConfig_min_chunk_length_get(swig_self());
  return swig_cres ? new optional_int(swig_cres, false) : nullptr;
}
inline SentenceStreamCreationConfig::SentenceStreamCreationConfig() : SentenceStreamCreationConfig{inworld_SentenceStreamCreationConfig_new()} {}
inline SentenceStreamCreationConfig::SentenceStreamCreationConfig(SentenceStreamCreationConfig const & other) : SentenceStreamCreationConfig{inworld_SentenceStreamCreationConfig_copy(other.swig_self())} {}
inline StatusOr_SentenceStream SentenceStream::Create(InputStream_string const& llm_stream) {
  auto swig_cres = inworld_SentenceStream_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg_(llm_stream.swig_self());
  return StatusOr_SentenceStream{swig_cres, true};
}
inline StatusOr_SentenceStream SentenceStream::Create(InputStream_string const& llm_stream, SentenceStreamCreationConfig const & arg2) {
  auto swig_cres = inworld_SentenceStream_Create_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_SentenceStreamCreationConfig(llm_stream.swig_self(), arg2.swig_self());
  return StatusOr_SentenceStream{swig_cres, true};
}
inline bool SentenceStream::is_valid() const { return inworld_SentenceStream_is_valid(swig_self()); }
inline StatusOr_SubstringRemover SubstringRemover::Create(InputStream_string const& input_stream, vector_string const & arg2) {
  auto swig_cres = inworld_SubstringRemover_Create(input_stream.swig_self(), arg2.swig_self());
  return StatusOr_SubstringRemover{swig_cres, true};
}
inline bool SubstringRemover::is_valid() const { return inworld_SubstringRemover_is_valid(swig_self()); }
inline StatusOr_TextInBracketsRemover TextInBracketsRemover::Create(InputStream_string const& input_stream) {
  auto swig_cres = inworld_TextInBracketsRemover_Create(input_stream.swig_self());
  return StatusOr_TextInBracketsRemover{swig_cres, true};
}
inline bool TextInBracketsRemover::is_valid() const { return inworld_TextInBracketsRemover_is_valid(swig_self()); }
inline optional_LocalSTTConfig::optional_LocalSTTConfig() : optional_LocalSTTConfig{inworld_optional_LocalSTTConfig_new()} {}
inline optional_LocalSTTConfig::optional_LocalSTTConfig(LocalSTTConfig const & value) : optional_LocalSTTConfig{inworld_optional_LocalSTTConfig_new_rcinworld_LocalSTTConfig(value.swig_self())} {}
inline optional_LocalSTTConfig::optional_LocalSTTConfig(optional_LocalSTTConfig const & other) : optional_LocalSTTConfig{inworld_optional_LocalSTTConfig_copy(other.swig_self())} {}
inline bool optional_LocalSTTConfig::has_value() const { return inworld_optional_LocalSTTConfig_has_value(swig_self()); }
inline LocalSTTConfig optional_LocalSTTConfig::value() {
  auto swig_cres = inworld_optional_LocalSTTConfig_value(swig_self());
  return LocalSTTConfig{swig_cres, false};
}
inline LocalSTTConfig optional_LocalSTTConfig::value() const {
  auto swig_cres = inworld_optional_LocalSTTConfig_valueConst(swig_self());
  return LocalSTTConfig{swig_cres, false};
}
inline LocalSTTConfig optional_LocalSTTConfig::value_or(LocalSTTConfig const & default_value) const {
  auto swig_cres = inworld_optional_LocalSTTConfig_value_or(swig_self(), default_value.swig_self());
  return LocalSTTConfig{swig_cres, true};
}
inline void optional_LocalSTTConfig::reset() { inworld_optional_LocalSTTConfig_reset(swig_self()); }
inline LocalSTTConfig optional_LocalSTTConfig::operator *() {
  auto swig_cres = inworld_optional_LocalSTTConfig_get(swig_self());
  return LocalSTTConfig{swig_cres, false};
}
inline LocalSTTConfig optional_LocalSTTConfig::operator *() const {
  auto swig_cres = inworld_optional_LocalSTTConfig_getConst(swig_self());
  return LocalSTTConfig{swig_cres, false};
}
inline LocalSTTConfig optional_LocalSTTConfig::get_value() {
  auto swig_cres = inworld_optional_LocalSTTConfig_get_value(swig_self());
  return LocalSTTConfig{swig_cres, false};
}
inline void optional_LocalSTTConfig::set_value(LocalSTTConfig & t) { inworld_optional_LocalSTTConfig_set_value(swig_self(), t.swig_self()); }
inline optional_RemoteSTTConfig::optional_RemoteSTTConfig() : optional_RemoteSTTConfig{inworld_optional_RemoteSTTConfig_new()} {}
inline optional_RemoteSTTConfig::optional_RemoteSTTConfig(RemoteSTTConfig const & value) : optional_RemoteSTTConfig{inworld_optional_RemoteSTTConfig_new_rcinworld_RemoteSTTConfig(value.swig_self())} {}
inline optional_RemoteSTTConfig::optional_RemoteSTTConfig(optional_RemoteSTTConfig const & other) : optional_RemoteSTTConfig{inworld_optional_RemoteSTTConfig_copy(other.swig_self())} {}
inline bool optional_RemoteSTTConfig::has_value() const { return inworld_optional_RemoteSTTConfig_has_value(swig_self()); }
inline RemoteSTTConfig optional_RemoteSTTConfig::value() {
  auto swig_cres = inworld_optional_RemoteSTTConfig_value(swig_self());
  return RemoteSTTConfig{swig_cres, false};
}
inline RemoteSTTConfig optional_RemoteSTTConfig::value() const {
  auto swig_cres = inworld_optional_RemoteSTTConfig_valueConst(swig_self());
  return RemoteSTTConfig{swig_cres, false};
}
inline RemoteSTTConfig optional_RemoteSTTConfig::value_or(RemoteSTTConfig const & default_value) const {
  auto swig_cres = inworld_optional_RemoteSTTConfig_value_or(swig_self(), default_value.swig_self());
  return RemoteSTTConfig{swig_cres, true};
}
inline void optional_RemoteSTTConfig::reset() { inworld_optional_RemoteSTTConfig_reset(swig_self()); }
inline RemoteSTTConfig optional_RemoteSTTConfig::operator *() {
  auto swig_cres = inworld_optional_RemoteSTTConfig_get(swig_self());
  return RemoteSTTConfig{swig_cres, false};
}
inline RemoteSTTConfig optional_RemoteSTTConfig::operator *() const {
  auto swig_cres = inworld_optional_RemoteSTTConfig_getConst(swig_self());
  return RemoteSTTConfig{swig_cres, false};
}
inline RemoteSTTConfig optional_RemoteSTTConfig::get_value() {
  auto swig_cres = inworld_optional_RemoteSTTConfig_get_value(swig_self());
  return RemoteSTTConfig{swig_cres, false};
}
inline void optional_RemoteSTTConfig::set_value(RemoteSTTConfig & t) { inworld_optional_RemoteSTTConfig_set_value(swig_self(), t.swig_self()); }
inline optional_Language::optional_Language() : optional_Language{inworld_optional_Language_new()} {}
inline optional_Language::optional_Language(Language const & value) : optional_Language{inworld_optional_Language_new_rcinworld_library_Language(value.swig_self())} {}
inline optional_Language::optional_Language(optional_Language const & other) : optional_Language{inworld_optional_Language_copy(other.swig_self())} {}
inline bool optional_Language::has_value() const { return inworld_optional_Language_has_value(swig_self()); }
inline Language optional_Language::value() {
  auto swig_cres = inworld_optional_Language_value(swig_self());
  return Language{swig_cres, false};
}
inline Language optional_Language::value() const {
  auto swig_cres = inworld_optional_Language_valueConst(swig_self());
  return Language{swig_cres, false};
}
inline Language optional_Language::value_or(Language const & default_value) const {
  auto swig_cres = inworld_optional_Language_value_or(swig_self(), default_value.swig_self());
  return Language{swig_cres, true};
}
inline void optional_Language::reset() { inworld_optional_Language_reset(swig_self()); }
inline Language optional_Language::operator *() {
  auto swig_cres = inworld_optional_Language_get(swig_self());
  return Language{swig_cres, false};
}
inline Language optional_Language::operator *() const {
  auto swig_cres = inworld_optional_Language_getConst(swig_self());
  return Language{swig_cres, false};
}
inline Language optional_Language::get_value() {
  auto swig_cres = inworld_optional_Language_get_value(swig_self());
  return Language{swig_cres, false};
}
inline void optional_Language::set_value(Language & t) { inworld_optional_Language_set_value(swig_self(), t.swig_self()); }
inline void LocalSTTConfig::model_path(std::string const& model_path) { inworld_LocalSTTConfig_model_path_set(swig_self(), (&model_path)->c_str()); }
inline std::string LocalSTTConfig::model_path() const {
  auto swig_cres = inworld_LocalSTTConfig_model_path_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LocalSTTConfig::device(Device * device) { inworld_LocalSTTConfig_device_set(swig_self(), device->swig_self()); }
inline Device * LocalSTTConfig::device() const {
  auto swig_cres = inworld_LocalSTTConfig_device_get(swig_self());
  return swig_cres ? new Device(swig_cres, false) : nullptr;
}
inline void LocalSTTConfig::default_config(SpeechRecognitionConfig * default_config) { inworld_LocalSTTConfig_default_config_set(swig_self(), default_config->swig_self()); }
inline SpeechRecognitionConfig * LocalSTTConfig::default_config() const {
  auto swig_cres = inworld_LocalSTTConfig_default_config_get(swig_self());
  return swig_cres ? new SpeechRecognitionConfig(swig_cres, false) : nullptr;
}
inline LocalSTTConfig::LocalSTTConfig() : LocalSTTConfig{inworld_LocalSTTConfig_new()} {}
inline LocalSTTConfig::LocalSTTConfig(LocalSTTConfig const & other) : LocalSTTConfig{inworld_LocalSTTConfig_copy(other.swig_self())} {}
inline void RemoteSTTConfig::api_key(std::string const& api_key) { inworld_RemoteSTTConfig_api_key_set(swig_self(), (&api_key)->c_str()); }
inline std::string RemoteSTTConfig::api_key() const {
  auto swig_cres = inworld_RemoteSTTConfig_api_key_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RemoteSTTConfig::default_config(SpeechRecognitionConfig * default_config) { inworld_RemoteSTTConfig_default_config_set(swig_self(), default_config->swig_self()); }
inline SpeechRecognitionConfig * RemoteSTTConfig::default_config() const {
  auto swig_cres = inworld_RemoteSTTConfig_default_config_get(swig_self());
  return swig_cres ? new SpeechRecognitionConfig(swig_cres, false) : nullptr;
}
inline RemoteSTTConfig::RemoteSTTConfig() : RemoteSTTConfig{inworld_RemoteSTTConfig_new()} {}
inline RemoteSTTConfig::RemoteSTTConfig(RemoteSTTConfig const & other) : RemoteSTTConfig{inworld_RemoteSTTConfig_copy(other.swig_self())} {}
inline bool STTCreationConfig::has_local_config() { return inworld_STTCreationConfig_has_local_config(swig_self()); }
inline bool STTCreationConfig::has_remote_config() { return inworld_STTCreationConfig_has_remote_config(swig_self()); }
inline optional_LocalSTTConfig STTCreationConfig::get_local_config() {
  auto swig_cres = inworld_STTCreationConfig_get_local_config(swig_self());
  return optional_LocalSTTConfig{swig_cres, true};
}
inline optional_RemoteSTTConfig STTCreationConfig::get_remote_config() {
  auto swig_cres = inworld_STTCreationConfig_get_remote_config(swig_self());
  return optional_RemoteSTTConfig{swig_cres, true};
}
inline void STTCreationConfig::set_local_config(LocalSTTConfig const & config) { inworld_STTCreationConfig_set_local_config(swig_self(), config.swig_self()); }
inline void STTCreationConfig::set_remote_config(RemoteSTTConfig const & config) { inworld_STTCreationConfig_set_remote_config(swig_self(), config.swig_self()); }
inline STTCreationConfig::STTCreationConfig() : STTCreationConfig{inworld_STTCreationConfig_new()} {}
inline STTCreationConfig::STTCreationConfig(STTCreationConfig const & other) : STTCreationConfig{inworld_STTCreationConfig_copy(other.swig_self())} {}
inline StatusOr_STTInterface STTFactory::CreateSTT(LocalSTTConfig const & config) const {
  auto swig_cres = inworld_STTFactory_CreateSTT_rcinworld_LocalSTTConfig(swig_self(), config.swig_self());
  return StatusOr_STTInterface{swig_cres, true};
}
inline StatusOr_STTInterface STTFactory::CreateSTT(RemoteSTTConfig const & config) const {
  auto swig_cres = inworld_STTFactory_CreateSTT_rcinworld_RemoteSTTConfig(swig_self(), config.swig_self());
  return StatusOr_STTInterface{swig_cres, true};
}
inline STTFactory::STTFactory() : STTFactory{inworld_STTFactory_new()} {}
inline STTFactory::STTFactory(STTFactory const & other) : STTFactory{inworld_STTFactory_copy(other.swig_self())} {}
inline void StreamSpeechRecognitionConfig::speech_config(SpeechRecognitionConfig * speech_config) { inworld_StreamSpeechRecognitionConfig_speech_config_set(swig_self(), speech_config->swig_self()); }
inline SpeechRecognitionConfig * StreamSpeechRecognitionConfig::speech_config() const {
  auto swig_cres = inworld_StreamSpeechRecognitionConfig_speech_config_get(swig_self());
  return swig_cres ? new SpeechRecognitionConfig(swig_cres, false) : nullptr;
}
inline void StreamSpeechRecognitionConfig::silence_threshold_ms(int silence_threshold_ms) { inworld_StreamSpeechRecognitionConfig_silence_threshold_ms_set(swig_self(), silence_threshold_ms); }
inline int StreamSpeechRecognitionConfig::silence_threshold_ms() const { return inworld_StreamSpeechRecognitionConfig_silence_threshold_ms_get(swig_self()); }
inline StreamSpeechRecognitionConfig::StreamSpeechRecognitionConfig() : StreamSpeechRecognitionConfig{inworld_StreamSpeechRecognitionConfig_new()} {}
inline StreamSpeechRecognitionConfig::StreamSpeechRecognitionConfig(StreamSpeechRecognitionConfig const & other) : StreamSpeechRecognitionConfig{inworld_StreamSpeechRecognitionConfig_copy(other.swig_self())} {}
inline bool StreamingSTTInterface::is_valid() const { return inworld_StreamingSTTInterface_is_valid(swig_self()); }
inline optional_LocalStreamingSTTConfig::optional_LocalStreamingSTTConfig() : optional_LocalStreamingSTTConfig{inworld_optional_LocalStreamingSTTConfig_new()} {}
inline optional_LocalStreamingSTTConfig::optional_LocalStreamingSTTConfig(LocalStreamingSTTConfig const & value) : optional_LocalStreamingSTTConfig{inworld_optional_LocalStreamingSTTConfig_new_rcinworld_LocalStreamingSTTConfig(value.swig_self())} {}
inline optional_LocalStreamingSTTConfig::optional_LocalStreamingSTTConfig(optional_LocalStreamingSTTConfig const & other) : optional_LocalStreamingSTTConfig{inworld_optional_LocalStreamingSTTConfig_copy(other.swig_self())} {}
inline bool optional_LocalStreamingSTTConfig::has_value() const { return inworld_optional_LocalStreamingSTTConfig_has_value(swig_self()); }
inline LocalStreamingSTTConfig optional_LocalStreamingSTTConfig::value() {
  auto swig_cres = inworld_optional_LocalStreamingSTTConfig_value(swig_self());
  return LocalStreamingSTTConfig{swig_cres, false};
}
inline LocalStreamingSTTConfig optional_LocalStreamingSTTConfig::value() const {
  auto swig_cres = inworld_optional_LocalStreamingSTTConfig_valueConst(swig_self());
  return LocalStreamingSTTConfig{swig_cres, false};
}
inline LocalStreamingSTTConfig optional_LocalStreamingSTTConfig::value_or(LocalStreamingSTTConfig const & default_value) const {
  auto swig_cres = inworld_optional_LocalStreamingSTTConfig_value_or(swig_self(), default_value.swig_self());
  return LocalStreamingSTTConfig{swig_cres, true};
}
inline void optional_LocalStreamingSTTConfig::reset() { inworld_optional_LocalStreamingSTTConfig_reset(swig_self()); }
inline LocalStreamingSTTConfig optional_LocalStreamingSTTConfig::operator *() {
  auto swig_cres = inworld_optional_LocalStreamingSTTConfig_get(swig_self());
  return LocalStreamingSTTConfig{swig_cres, false};
}
inline LocalStreamingSTTConfig optional_LocalStreamingSTTConfig::operator *() const {
  auto swig_cres = inworld_optional_LocalStreamingSTTConfig_getConst(swig_self());
  return LocalStreamingSTTConfig{swig_cres, false};
}
inline LocalStreamingSTTConfig optional_LocalStreamingSTTConfig::get_value() {
  auto swig_cres = inworld_optional_LocalStreamingSTTConfig_get_value(swig_self());
  return LocalStreamingSTTConfig{swig_cres, false};
}
inline void optional_LocalStreamingSTTConfig::set_value(LocalStreamingSTTConfig & t) { inworld_optional_LocalStreamingSTTConfig_set_value(swig_self(), t.swig_self()); }
inline optional_RemoteStreamingSTTConfig::optional_RemoteStreamingSTTConfig() : optional_RemoteStreamingSTTConfig{inworld_optional_RemoteStreamingSTTConfig_new()} {}
inline optional_RemoteStreamingSTTConfig::optional_RemoteStreamingSTTConfig(RemoteStreamingSTTConfig const & value) : optional_RemoteStreamingSTTConfig{inworld_optional_RemoteStreamingSTTConfig_new_rcinworld_RemoteStreamingSTTConfig(value.swig_self())} {}
inline optional_RemoteStreamingSTTConfig::optional_RemoteStreamingSTTConfig(optional_RemoteStreamingSTTConfig const & other) : optional_RemoteStreamingSTTConfig{inworld_optional_RemoteStreamingSTTConfig_copy(other.swig_self())} {}
inline bool optional_RemoteStreamingSTTConfig::has_value() const { return inworld_optional_RemoteStreamingSTTConfig_has_value(swig_self()); }
inline RemoteStreamingSTTConfig optional_RemoteStreamingSTTConfig::value() {
  auto swig_cres = inworld_optional_RemoteStreamingSTTConfig_value(swig_self());
  return RemoteStreamingSTTConfig{swig_cres, false};
}
inline RemoteStreamingSTTConfig optional_RemoteStreamingSTTConfig::value() const {
  auto swig_cres = inworld_optional_RemoteStreamingSTTConfig_valueConst(swig_self());
  return RemoteStreamingSTTConfig{swig_cres, false};
}
inline RemoteStreamingSTTConfig optional_RemoteStreamingSTTConfig::value_or(RemoteStreamingSTTConfig const & default_value) const {
  auto swig_cres = inworld_optional_RemoteStreamingSTTConfig_value_or(swig_self(), default_value.swig_self());
  return RemoteStreamingSTTConfig{swig_cres, true};
}
inline void optional_RemoteStreamingSTTConfig::reset() { inworld_optional_RemoteStreamingSTTConfig_reset(swig_self()); }
inline RemoteStreamingSTTConfig optional_RemoteStreamingSTTConfig::operator *() {
  auto swig_cres = inworld_optional_RemoteStreamingSTTConfig_get(swig_self());
  return RemoteStreamingSTTConfig{swig_cres, false};
}
inline RemoteStreamingSTTConfig optional_RemoteStreamingSTTConfig::operator *() const {
  auto swig_cres = inworld_optional_RemoteStreamingSTTConfig_getConst(swig_self());
  return RemoteStreamingSTTConfig{swig_cres, false};
}
inline RemoteStreamingSTTConfig optional_RemoteStreamingSTTConfig::get_value() {
  auto swig_cres = inworld_optional_RemoteStreamingSTTConfig_get_value(swig_self());
  return RemoteStreamingSTTConfig{swig_cres, false};
}
inline void optional_RemoteStreamingSTTConfig::set_value(RemoteStreamingSTTConfig & t) { inworld_optional_RemoteStreamingSTTConfig_set_value(swig_self(), t.swig_self()); }
inline void LocalStreamingSTTConfig::stt_model_path(std::string const& stt_model_path) { inworld_LocalStreamingSTTConfig_stt_model_path_set(swig_self(), (&stt_model_path)->c_str()); }
inline std::string LocalStreamingSTTConfig::stt_model_path() const {
  auto swig_cres = inworld_LocalStreamingSTTConfig_stt_model_path_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LocalStreamingSTTConfig::vad_model_path(std::string const& vad_model_path) { inworld_LocalStreamingSTTConfig_vad_model_path_set(swig_self(), (&vad_model_path)->c_str()); }
inline std::string LocalStreamingSTTConfig::vad_model_path() const {
  auto swig_cres = inworld_LocalStreamingSTTConfig_vad_model_path_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LocalStreamingSTTConfig::stt_device(Device * stt_device) { inworld_LocalStreamingSTTConfig_stt_device_set(swig_self(), stt_device->swig_self()); }
inline Device * LocalStreamingSTTConfig::stt_device() const {
  auto swig_cres = inworld_LocalStreamingSTTConfig_stt_device_get(swig_self());
  return swig_cres ? new Device(swig_cres, false) : nullptr;
}
inline void LocalStreamingSTTConfig::vad_device(Device * vad_device) { inworld_LocalStreamingSTTConfig_vad_device_set(swig_self(), vad_device->swig_self()); }
inline Device * LocalStreamingSTTConfig::vad_device() const {
  auto swig_cres = inworld_LocalStreamingSTTConfig_vad_device_get(swig_self());
  return swig_cres ? new Device(swig_cres, false) : nullptr;
}
inline void LocalStreamingSTTConfig::default_config(StreamSpeechRecognitionConfig * default_config) { inworld_LocalStreamingSTTConfig_default_config_set(swig_self(), default_config->swig_self()); }
inline StreamSpeechRecognitionConfig * LocalStreamingSTTConfig::default_config() const {
  auto swig_cres = inworld_LocalStreamingSTTConfig_default_config_get(swig_self());
  return swig_cres ? new StreamSpeechRecognitionConfig(swig_cres, false) : nullptr;
}
inline LocalStreamingSTTConfig::LocalStreamingSTTConfig() : LocalStreamingSTTConfig{inworld_LocalStreamingSTTConfig_new()} {}
inline LocalStreamingSTTConfig::LocalStreamingSTTConfig(LocalStreamingSTTConfig const & other) : LocalStreamingSTTConfig{inworld_LocalStreamingSTTConfig_copy(other.swig_self())} {}
inline void RemoteStreamingSTTConfig::api_key(std::string const& api_key) { inworld_RemoteStreamingSTTConfig_api_key_set(swig_self(), (&api_key)->c_str()); }
inline std::string RemoteStreamingSTTConfig::api_key() const {
  auto swig_cres = inworld_RemoteStreamingSTTConfig_api_key_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RemoteStreamingSTTConfig::default_config(StreamSpeechRecognitionConfig * default_config) { inworld_RemoteStreamingSTTConfig_default_config_set(swig_self(), default_config->swig_self()); }
inline StreamSpeechRecognitionConfig * RemoteStreamingSTTConfig::default_config() const {
  auto swig_cres = inworld_RemoteStreamingSTTConfig_default_config_get(swig_self());
  return swig_cres ? new StreamSpeechRecognitionConfig(swig_cres, false) : nullptr;
}
inline RemoteStreamingSTTConfig::RemoteStreamingSTTConfig() : RemoteStreamingSTTConfig{inworld_RemoteStreamingSTTConfig_new()} {}
inline RemoteStreamingSTTConfig::RemoteStreamingSTTConfig(RemoteStreamingSTTConfig const & other) : RemoteStreamingSTTConfig{inworld_RemoteStreamingSTTConfig_copy(other.swig_self())} {}
inline bool StreamingSTTCreationConfig::has_local_config() { return inworld_StreamingSTTCreationConfig_has_local_config(swig_self()); }
inline bool StreamingSTTCreationConfig::has_remote_config() { return inworld_StreamingSTTCreationConfig_has_remote_config(swig_self()); }
inline optional_LocalStreamingSTTConfig StreamingSTTCreationConfig::get_local_config() {
  auto swig_cres = inworld_StreamingSTTCreationConfig_get_local_config(swig_self());
  return optional_LocalStreamingSTTConfig{swig_cres, true};
}
inline optional_RemoteStreamingSTTConfig StreamingSTTCreationConfig::get_remote_config() {
  auto swig_cres = inworld_StreamingSTTCreationConfig_get_remote_config(swig_self());
  return optional_RemoteStreamingSTTConfig{swig_cres, true};
}
inline void StreamingSTTCreationConfig::set_local_config(LocalStreamingSTTConfig const & config) { inworld_StreamingSTTCreationConfig_set_local_config(swig_self(), config.swig_self()); }
inline void StreamingSTTCreationConfig::set_remote_config(RemoteStreamingSTTConfig const & config) { inworld_StreamingSTTCreationConfig_set_remote_config(swig_self(), config.swig_self()); }
inline StreamingSTTCreationConfig::StreamingSTTCreationConfig() : StreamingSTTCreationConfig{inworld_StreamingSTTCreationConfig_new()} {}
inline StreamingSTTCreationConfig::StreamingSTTCreationConfig(StreamingSTTCreationConfig const & other) : StreamingSTTCreationConfig{inworld_StreamingSTTCreationConfig_copy(other.swig_self())} {}
inline StreamingSTTFactory::StreamingSTTFactory() : StreamingSTTFactory{inworld_StreamingSTTFactory_new()} {}
inline StreamingSTTFactory::StreamingSTTFactory(StreamingSTTFactory const & other) : StreamingSTTFactory{inworld_StreamingSTTFactory_copy(other.swig_self())} {}
inline optional_RemoteTTSConfig::optional_RemoteTTSConfig() : optional_RemoteTTSConfig{inworld_optional_RemoteTTSConfig_new()} {}
inline optional_RemoteTTSConfig::optional_RemoteTTSConfig(RemoteTTSConfig const & value) : optional_RemoteTTSConfig{inworld_optional_RemoteTTSConfig_new_rcinworld_RemoteTTSConfig(value.swig_self())} {}
inline optional_RemoteTTSConfig::optional_RemoteTTSConfig(optional_RemoteTTSConfig const & other) : optional_RemoteTTSConfig{inworld_optional_RemoteTTSConfig_copy(other.swig_self())} {}
inline bool optional_RemoteTTSConfig::has_value() const { return inworld_optional_RemoteTTSConfig_has_value(swig_self()); }
inline RemoteTTSConfig optional_RemoteTTSConfig::value() {
  auto swig_cres = inworld_optional_RemoteTTSConfig_value(swig_self());
  return RemoteTTSConfig{swig_cres, false};
}
inline RemoteTTSConfig optional_RemoteTTSConfig::value() const {
  auto swig_cres = inworld_optional_RemoteTTSConfig_valueConst(swig_self());
  return RemoteTTSConfig{swig_cres, false};
}
inline RemoteTTSConfig optional_RemoteTTSConfig::value_or(RemoteTTSConfig const & default_value) const {
  auto swig_cres = inworld_optional_RemoteTTSConfig_value_or(swig_self(), default_value.swig_self());
  return RemoteTTSConfig{swig_cres, true};
}
inline void optional_RemoteTTSConfig::reset() { inworld_optional_RemoteTTSConfig_reset(swig_self()); }
inline RemoteTTSConfig optional_RemoteTTSConfig::operator *() {
  auto swig_cres = inworld_optional_RemoteTTSConfig_get(swig_self());
  return RemoteTTSConfig{swig_cres, false};
}
inline RemoteTTSConfig optional_RemoteTTSConfig::operator *() const {
  auto swig_cres = inworld_optional_RemoteTTSConfig_getConst(swig_self());
  return RemoteTTSConfig{swig_cres, false};
}
inline RemoteTTSConfig optional_RemoteTTSConfig::get_value() {
  auto swig_cres = inworld_optional_RemoteTTSConfig_get_value(swig_self());
  return RemoteTTSConfig{swig_cres, false};
}
inline void optional_RemoteTTSConfig::set_value(RemoteTTSConfig & t) { inworld_optional_RemoteTTSConfig_set_value(swig_self(), t.swig_self()); }
inline LocalTTSConfig::LocalTTSConfig() : LocalTTSConfig{inworld_LocalTTSConfig_new()} {}
inline LocalTTSConfig::LocalTTSConfig(LocalTTSConfig const & other) : LocalTTSConfig{inworld_LocalTTSConfig_copy(other.swig_self())} {}
inline void RemoteTTSConfig::api_key(std::string const& api_key) { inworld_RemoteTTSConfig_api_key_set(swig_self(), (&api_key)->c_str()); }
inline std::string RemoteTTSConfig::api_key() const {
  auto swig_cres = inworld_RemoteTTSConfig_api_key_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void RemoteTTSConfig::synthesis_config(SpeechSynthesisConfig * synthesis_config) { inworld_RemoteTTSConfig_synthesis_config_set(swig_self(), synthesis_config->swig_self()); }
inline SpeechSynthesisConfig * RemoteTTSConfig::synthesis_config() const {
  auto swig_cres = inworld_RemoteTTSConfig_synthesis_config_get(swig_self());
  return swig_cres ? new SpeechSynthesisConfig(swig_cres, false) : nullptr;
}
inline RemoteTTSConfig::RemoteTTSConfig() : RemoteTTSConfig{inworld_RemoteTTSConfig_new()} {}
inline RemoteTTSConfig::RemoteTTSConfig(RemoteTTSConfig const & other) : RemoteTTSConfig{inworld_RemoteTTSConfig_copy(other.swig_self())} {}
inline bool TTSCreationConfig::has_remote_config() { return inworld_TTSCreationConfig_has_remote_config(swig_self()); }
inline optional_RemoteTTSConfig TTSCreationConfig::get_remote_config() {
  auto swig_cres = inworld_TTSCreationConfig_get_remote_config(swig_self());
  return optional_RemoteTTSConfig{swig_cres, true};
}
inline void TTSCreationConfig::set_remote_config(RemoteTTSConfig const & config) { inworld_TTSCreationConfig_set_remote_config(swig_self(), config.swig_self()); }
inline TTSCreationConfig::TTSCreationConfig() : TTSCreationConfig{inworld_TTSCreationConfig_new()} {}
inline TTSCreationConfig::TTSCreationConfig(TTSCreationConfig const & other) : TTSCreationConfig{inworld_TTSCreationConfig_copy(other.swig_self())} {}
inline StatusOr_TTSInterface TTSFactory::CreateTTS(RemoteTTSConfig const & config) const {
  auto swig_cres = inworld_TTSFactory_CreateTTS(swig_self(), config.swig_self());
  return StatusOr_TTSInterface{swig_cres, true};
}
inline TTSFactory::TTSFactory() : TTSFactory{inworld_TTSFactory_new()} {}
inline TTSFactory::TTSFactory(TTSFactory const & other) : TTSFactory{inworld_TTSFactory_copy(other.swig_self())} {}
inline SilenceIntervals::SilenceIntervals() : SilenceIntervals{inworld_SilenceIntervals_new()} {}
inline SilenceIntervals::SilenceIntervals(SilenceIntervals const & other) : SilenceIntervals{inworld_SilenceIntervals_copy(other.swig_self())} {}
inline size_t SilenceIntervals::size() const { return inworld_SilenceIntervals_size(swig_self()); }
inline size_t SilenceIntervals::capacity() const { return inworld_SilenceIntervals_capacity(swig_self()); }
inline void SilenceIntervals::reserve(size_t n) { inworld_SilenceIntervals_reserve(swig_self(), n); }
inline bool SilenceIntervals::empty() const { return inworld_SilenceIntervals_empty(swig_self()); }
inline void SilenceIntervals::clear() { inworld_SilenceIntervals_clear(swig_self()); }
inline void SilenceIntervals::push_back(IntPair const & x) { inworld_SilenceIntervals_push_back(swig_self(), x.swig_self()); }
inline IntPair SilenceIntervals::get(int i) {
  auto swig_cres = inworld_SilenceIntervals_get(swig_self(), i);
  return IntPair{swig_cres, false};
}
inline void SilenceIntervals::set(int i, IntPair const & arg3) { inworld_SilenceIntervals_set(swig_self(), i, arg3.swig_self()); }
inline IntPair::IntPair() : IntPair{inworld_IntPair_new()} {}
inline IntPair::IntPair(int first, int arg2) : IntPair{inworld_IntPair_new_i_i(first, arg2)} {}
inline IntPair::IntPair(IntPair const & other) : IntPair{inworld_IntPair_copy(other.swig_self())} {}
inline void IntPair::first(int first) { inworld_IntPair_first_set(swig_self(), first); }
inline int IntPair::first() const { return inworld_IntPair_first_get(swig_self()); }
inline void IntPair::second(int second) { inworld_IntPair_second_set(swig_self(), second); }
inline int IntPair::second() const { return inworld_IntPair_second_get(swig_self()); }
inline void VoiceActivityDetectionConfig::speech_threshold(float speech_threshold) { inworld_VoiceActivityDetectionConfig_speech_threshold_set(swig_self(), speech_threshold); }
inline float VoiceActivityDetectionConfig::speech_threshold() const { return inworld_VoiceActivityDetectionConfig_speech_threshold_get(swig_self()); }
inline VoiceActivityDetectionConfig::VoiceActivityDetectionConfig() : VoiceActivityDetectionConfig{inworld_VoiceActivityDetectionConfig_new()} {}
inline VoiceActivityDetectionConfig::VoiceActivityDetectionConfig(VoiceActivityDetectionConfig const & other) : VoiceActivityDetectionConfig{inworld_VoiceActivityDetectionConfig_copy(other.swig_self())} {}
inline bool VADInterface::is_valid() const { return inworld_VADInterface_is_valid(swig_self()); }
inline StatusOr_int VADInterface::DetectVoiceActivity(AudioChunk const & audio_chunk, VoiceActivityDetectionConfig const & arg3) {
  auto swig_cres = inworld_VADInterface_DetectVoiceActivity_rcinworld_AudioChunk_rcinworld_VoiceActivityDetectionConfig(swig_self(), audio_chunk.swig_self(), arg3.swig_self());
  return StatusOr_int{swig_cres, true};
}
inline StatusOr_int VADInterface::DetectVoiceActivity(AudioChunk const & audio_chunk) {
  auto swig_cres = inworld_VADInterface_DetectVoiceActivity_rcinworld_AudioChunk(swig_self(), audio_chunk.swig_self());
  return StatusOr_int{swig_cres, true};
}
inline StatusOr_SilenceIntervals VADInterface::DetectSilence(vector_float const & audio_data, int arg3, VoiceActivityDetectionConfig const & arg4) {
  auto swig_cres = inworld_VADInterface_DetectSilence_rcstd_vector_Sl_float_Sg__i_rcinworld_VoiceActivityDetectionConfig(swig_self(), audio_data.swig_self(), arg3, arg4.swig_self());
  return StatusOr_SilenceIntervals{swig_cres, true};
}
inline StatusOr_SilenceIntervals VADInterface::DetectSilence(vector_float const & audio_data, int arg3) {
  auto swig_cres = inworld_VADInterface_DetectSilence_rcstd_vector_Sl_float_Sg__i(swig_self(), audio_data.swig_self(), arg3);
  return StatusOr_SilenceIntervals{swig_cres, true};
}
inline void LocalVADConfig::model_path(std::string const& model_path) { inworld_LocalVADConfig_model_path_set(swig_self(), (&model_path)->c_str()); }
inline std::string LocalVADConfig::model_path() const {
  auto swig_cres = inworld_LocalVADConfig_model_path_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LocalVADConfig::device(Device * device) { inworld_LocalVADConfig_device_set(swig_self(), device->swig_self()); }
inline Device * LocalVADConfig::device() const {
  auto swig_cres = inworld_LocalVADConfig_device_get(swig_self());
  return swig_cres ? new Device(swig_cres, false) : nullptr;
}
inline void LocalVADConfig::default_config(VoiceActivityDetectionConfig * default_config) { inworld_LocalVADConfig_default_config_set(swig_self(), default_config->swig_self()); }
inline VoiceActivityDetectionConfig * LocalVADConfig::default_config() const {
  auto swig_cres = inworld_LocalVADConfig_default_config_get(swig_self());
  return swig_cres ? new VoiceActivityDetectionConfig(swig_cres, false) : nullptr;
}
inline LocalVADConfig::LocalVADConfig() : LocalVADConfig{inworld_LocalVADConfig_new()} {}
inline LocalVADConfig::LocalVADConfig(LocalVADConfig const & other) : LocalVADConfig{inworld_LocalVADConfig_copy(other.swig_self())} {}
inline StatusOr_VADInterface VADFactory::CreateVAD(LocalVADConfig const & config) const {
  auto swig_cres = inworld_VADFactory_CreateVAD(swig_self(), config.swig_self());
  return StatusOr_VADInterface{swig_cres, true};
}
inline VADFactory::VADFactory() : VADFactory{inworld_VADFactory_new()} {}
inline VADFactory::VADFactory(VADFactory const & other) : VADFactory{inworld_VADFactory_copy(other.swig_self())} {}
inline AcousticEchoCancellationConfig::AcousticEchoCancellationConfig() : AcousticEchoCancellationConfig{inworld_AcousticEchoCancellationConfig_new()} {}
inline AcousticEchoCancellationConfig::AcousticEchoCancellationConfig(AcousticEchoCancellationConfig const & other) : AcousticEchoCancellationConfig{inworld_AcousticEchoCancellationConfig_copy(other.swig_self())} {}
inline bool AECFilterInterface::is_valid() const { return inworld_AECFilterInterface_is_valid(swig_self()); }
inline StatusOr_AudioChunk AECFilterInterface::FilterAudio(AudioChunk const & microphone_chunk, AudioChunk const & arg3) {
  auto swig_cres = inworld_AECFilterInterface_FilterAudio(swig_self(), microphone_chunk.swig_self(), arg3.swig_self());
  return StatusOr_AudioChunk{swig_cres, true};
}
inline void LocalAECFilterConfig::device(Device * device) { inworld_LocalAECFilterConfig_device_set(swig_self(), device->swig_self()); }
inline Device * LocalAECFilterConfig::device() const {
  auto swig_cres = inworld_LocalAECFilterConfig_device_get(swig_self());
  return swig_cres ? new Device(swig_cres, false) : nullptr;
}
inline void LocalAECFilterConfig::default_config(AcousticEchoCancellationConfig * default_config) { inworld_LocalAECFilterConfig_default_config_set(swig_self(), default_config->swig_self()); }
inline AcousticEchoCancellationConfig * LocalAECFilterConfig::default_config() const {
  auto swig_cres = inworld_LocalAECFilterConfig_default_config_get(swig_self());
  return swig_cres ? new AcousticEchoCancellationConfig(swig_cres, false) : nullptr;
}
inline LocalAECFilterConfig::LocalAECFilterConfig() : LocalAECFilterConfig{inworld_LocalAECFilterConfig_new()} {}
inline LocalAECFilterConfig::LocalAECFilterConfig(LocalAECFilterConfig const & other) : LocalAECFilterConfig{inworld_LocalAECFilterConfig_copy(other.swig_self())} {}
inline StatusOr_AECFilterInterface AECFilterFactory::CreateAECFilter(LocalAECFilterConfig const & config) const {
  auto swig_cres = inworld_AECFilterFactory_CreateAECFilter(swig_self(), config.swig_self());
  return StatusOr_AECFilterInterface{swig_cres, true};
}
inline AECFilterFactory::AECFilterFactory() : AECFilterFactory{inworld_AECFilterFactory_new()} {}
inline AECFilterFactory::AECFilterFactory(AECFilterFactory const & other) : AECFilterFactory{inworld_AECFilterFactory_copy(other.swig_self())} {}
inline std::string NodeExecutionTelemetryContext::execution_id() const {
  auto swig_cres = inworld_NodeExecutionTelemetryContext_execution_id(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline bool NodeExecutionTelemetryContext::is_valid() const { return inworld_NodeExecutionTelemetryContext_is_valid(swig_self()); }
inline bool CancellationContext::IsCancelled() const { return inworld_CancellationContext_IsCancelled(swig_self()); }
inline bool CancellationContext::is_valid() const { return inworld_CancellationContext_is_valid(swig_self()); }
inline ProcessContext::ProcessContext(ProcessContext const & arg1) : ProcessContext{inworld_ProcessContext_copy(arg1.swig_self())} {}
inline std::string ProcessContext::GetVariant() const {
  auto swig_cres = inworld_ProcessContext_GetVariant(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline std::string ProcessContext::GetExecutionId() const {
  auto swig_cres = inworld_ProcessContext_GetExecutionId(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline NodeExecutionConfig ProcessContext::GetConfig() const {
  auto swig_cres = inworld_ProcessContext_GetConfig(swig_self());
  return NodeExecutionConfig{swig_cres, true};
}
inline bool ProcessContext::IsCancelled() const { return inworld_ProcessContext_IsCancelled(swig_self()); }
inline CancellationContext ProcessContext::GetCancellationContext() const {
  auto swig_cres = inworld_ProcessContext_GetCancellationContext(swig_self());
  return CancellationContext{swig_cres, true};
}
inline NodeExecutionTelemetryContext ProcessContext::GetNodeExecutionTelemetryContext() const {
  auto swig_cres = inworld_ProcessContext_GetNodeExecutionTelemetryContext(swig_self());
  return NodeExecutionTelemetryContext{swig_cres, true};
}
inline StatusOr_SharedPtr_GoalAdvancementNode ProcessContext::GetComponent_GoalAdvancementNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_GoalAdvancementNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_GoalAdvancementNode{swig_cres, true};
}
inline StatusOr_SharedPtr_IntentNode ProcessContext::GetComponent_IntentNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_IntentNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_IntentNode{swig_cres, true};
}
inline StatusOr_SharedPtr_KeywordMatcherNode ProcessContext::GetComponent_KeywordMatcherNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_KeywordMatcherNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_KeywordMatcherNode{swig_cres, true};
}
inline StatusOr_SharedPtr_KnowledgeNode ProcessContext::GetComponent_KnowledgeNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_KnowledgeNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_KnowledgeNode{swig_cres, true};
}
inline StatusOr_SharedPtr_LLMChatNode ProcessContext::GetComponent_LLMChatNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_LLMChatNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_LLMChatNode{swig_cres, true};
}
inline StatusOr_SharedPtr_LLMCompletionNode ProcessContext::GetComponent_LLMCompletionNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_LLMCompletionNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_LLMCompletionNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MemoryUpdateNode ProcessContext::GetComponent_MemoryUpdateNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_MemoryUpdateNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_MemoryUpdateNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MemoryRetrieveNode ProcessContext::GetComponent_MemoryRetrieveNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_MemoryRetrieveNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_MemoryRetrieveNode{swig_cres, true};
}
inline StatusOr_SharedPtr_RandomCannedTextNode ProcessContext::GetComponent_RandomCannedTextNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_RandomCannedTextNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_RandomCannedTextNode{swig_cres, true};
}
inline StatusOr_SharedPtr_SafetyCheckerNode ProcessContext::GetComponent_SafetyCheckerNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_SafetyCheckerNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_SafetyCheckerNode{swig_cres, true};
}
inline StatusOr_SharedPtr_STTNode ProcessContext::GetComponent_STTNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_STTNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_STTNode{swig_cres, true};
}
inline StatusOr_SharedPtr_TextAggregatorNode ProcessContext::GetComponent_TextAggregatorNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_TextAggregatorNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_TextAggregatorNode{swig_cres, true};
}
inline StatusOr_SharedPtr_TextChunkingNode ProcessContext::GetComponent_TextChunkingNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_TextChunkingNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_TextChunkingNode{swig_cres, true};
}
inline StatusOr_SharedPtr_TTSNode ProcessContext::GetComponent_TTSNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_TTSNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_TTSNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MCPListToolsNode ProcessContext::GetComponent_MCPListToolsNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_MCPListToolsNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_MCPListToolsNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MCPCallToolNode ProcessContext::GetComponent_MCPCallToolNode(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_MCPCallToolNode(swig_self(), (&id)->c_str());
  return StatusOr_SharedPtr_MCPCallToolNode{swig_cres, true};
}
inline StatusOr_LLMInterface ProcessContext::GetComponent_LLMInterface(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_LLMInterface(swig_self(), (&id)->c_str());
  return StatusOr_LLMInterface{swig_cres, true};
}
inline StatusOr_STTInterface ProcessContext::GetComponent_STTInterface(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_STTInterface(swig_self(), (&id)->c_str());
  return StatusOr_STTInterface{swig_cres, true};
}
inline StatusOr_StreamingSTTInterface ProcessContext::GetComponent_StreamingSTTInterface(std::string const& id) {
  auto swig_cres = inworld_ProcessContext_GetComponent_StreamingSTTInterface(swig_self(), (&id)->c_str());
  return StatusOr_StreamingSTTInterface{swig_cres, true};
}
inline StatusOr_TTSInterface ProcessContext::GetComponent_TTSInterface(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_TTSInterface(swig_self(), (&id)->c_str());
  return StatusOr_TTSInterface{swig_cres, true};
}
inline StatusOr_TextEmbedderInterface ProcessContext::GetComponent_TextEmbedderInterface(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_TextEmbedderInterface(swig_self(), (&id)->c_str());
  return StatusOr_TextEmbedderInterface{swig_cres, true};
}
inline StatusOr_KnowledgeInterface ProcessContext::GetComponent_KnowledgeInterface(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_KnowledgeInterface(swig_self(), (&id)->c_str());
  return StatusOr_KnowledgeInterface{swig_cres, true};
}
inline StatusOr_MCPClientInterface ProcessContext::GetComponent_MCPClientInterface(std::string const& id) const {
  auto swig_cres = inworld_ProcessContext_GetComponent_MCPClientInterface(swig_self(), (&id)->c_str());
  return StatusOr_MCPClientInterface{swig_cres, true};
}
inline vector_BaseData::vector_BaseData() : vector_BaseData{inworld_vector_BaseData_new()} {}
inline vector_BaseData::vector_BaseData(vector_BaseData const & other) : vector_BaseData{inworld_vector_BaseData_copy(other.swig_self())} {}
inline size_t vector_BaseData::size() const { return inworld_vector_BaseData_size(swig_self()); }
inline size_t vector_BaseData::capacity() const { return inworld_vector_BaseData_capacity(swig_self()); }
inline void vector_BaseData::reserve(size_t n) { inworld_vector_BaseData_reserve(swig_self(), n); }
inline bool vector_BaseData::empty() const { return inworld_vector_BaseData_empty(swig_self()); }
inline void vector_BaseData::clear() { inworld_vector_BaseData_clear(swig_self()); }
inline void vector_BaseData::push_back(BaseData const& x) { inworld_vector_BaseData_push_back(swig_self(), x.swig_self()); }
inline BaseData vector_BaseData::get(int i) {
  auto swig_cres = inworld_vector_BaseData_get(swig_self(), i);
  return BaseData{swig_cres, true};
}
inline void vector_BaseData::set(int i, BaseData const& arg3) { inworld_vector_BaseData_set(swig_self(), i, arg3.swig_self()); }
inline BaseData vector_BaseData::safe_get(size_t index) const {
  auto swig_cres = inworld_vector_BaseData_safe_get(swig_self(), index);
  return BaseData{swig_cres, true};
}
inline vector_Text::vector_Text() : vector_Text{inworld_vector_Text_new()} {}
inline vector_Text::vector_Text(vector_Text const & other) : vector_Text{inworld_vector_Text_copy(other.swig_self())} {}
inline size_t vector_Text::size() const { return inworld_vector_Text_size(swig_self()); }
inline size_t vector_Text::capacity() const { return inworld_vector_Text_capacity(swig_self()); }
inline void vector_Text::reserve(size_t n) { inworld_vector_Text_reserve(swig_self(), n); }
inline bool vector_Text::empty() const { return inworld_vector_Text_empty(swig_self()); }
inline void vector_Text::clear() { inworld_vector_Text_clear(swig_self()); }
inline void vector_Text::push_back(Text const& x) { inworld_vector_Text_push_back(swig_self(), x.swig_self()); }
inline Text vector_Text::get(int i) {
  auto swig_cres = inworld_vector_Text_get(swig_self(), i);
  return Text{swig_cres, true};
}
inline void vector_Text::set(int i, Text const& arg3) { inworld_vector_Text_set(swig_self(), i, arg3.swig_self()); }
inline vector_ToolCallResult::vector_ToolCallResult() : vector_ToolCallResult{inworld_vector_ToolCallResult_new()} {}
inline vector_ToolCallResult::vector_ToolCallResult(vector_ToolCallResult const & other) : vector_ToolCallResult{inworld_vector_ToolCallResult_copy(other.swig_self())} {}
inline size_t vector_ToolCallResult::size() const { return inworld_vector_ToolCallResult_size(swig_self()); }
inline size_t vector_ToolCallResult::capacity() const { return inworld_vector_ToolCallResult_capacity(swig_self()); }
inline void vector_ToolCallResult::reserve(size_t n) { inworld_vector_ToolCallResult_reserve(swig_self(), n); }
inline bool vector_ToolCallResult::empty() const { return inworld_vector_ToolCallResult_empty(swig_self()); }
inline void vector_ToolCallResult::clear() { inworld_vector_ToolCallResult_clear(swig_self()); }
inline void vector_ToolCallResult::push_back(ToolCallResult const& x) { inworld_vector_ToolCallResult_push_back(swig_self(), x.swig_self()); }
inline ToolCallResult vector_ToolCallResult::get(int i) {
  auto swig_cres = inworld_vector_ToolCallResult_get(swig_self(), i);
  return ToolCallResult{swig_cres, true};
}
inline void vector_ToolCallResult::set(int i, ToolCallResult const& arg3) { inworld_vector_ToolCallResult_set(swig_self(), i, arg3.swig_self()); }
inline StatusOr_Json::StatusOr_Json() : StatusOr_Json{inworld_StatusOr_Json_new()} {}
inline StatusOr_Json::StatusOr_Json(Json const& value) : StatusOr_Json{inworld_StatusOr_Json_new_rcstd_shared_ptr_Sl_inworld_graphs_Json_Sg_(value.swig_self())} {}
inline StatusOr_Json::StatusOr_Json(Status const & status) : StatusOr_Json{inworld_StatusOr_Json_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_Json::ok() const { return inworld_StatusOr_Json_ok(swig_self()); }
inline Status StatusOr_Json::status() const {
  auto swig_cres = inworld_StatusOr_Json_status(swig_self());
  return Status{swig_cres, false};
}
inline Json StatusOr_Json::value() const {
  auto swig_cres = inworld_StatusOr_Json_value(swig_self());
  return Json{swig_cres, true};
}
inline StatusOr_Json::StatusOr_Json(StatusOr_Json const & other) : StatusOr_Json{inworld_StatusOr_Json_copy(other.swig_self())} {}
inline StatusOr_LLMCompletionRequest::StatusOr_LLMCompletionRequest() : StatusOr_LLMCompletionRequest{inworld_StatusOr_LLMCompletionRequest_new()} {}
inline StatusOr_LLMCompletionRequest::StatusOr_LLMCompletionRequest(LLMCompletionRequest const& value) : StatusOr_LLMCompletionRequest{inworld_StatusOr_LLMCompletionRequest_new_rcstd_shared_ptr_Sl_inworld_graphs_LLMCompletionRequest_Sg_(value.swig_self())} {}
inline StatusOr_LLMCompletionRequest::StatusOr_LLMCompletionRequest(Status const & status) : StatusOr_LLMCompletionRequest{inworld_StatusOr_LLMCompletionRequest_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_LLMCompletionRequest::ok() const { return inworld_StatusOr_LLMCompletionRequest_ok(swig_self()); }
inline Status StatusOr_LLMCompletionRequest::status() const {
  auto swig_cres = inworld_StatusOr_LLMCompletionRequest_status(swig_self());
  return Status{swig_cres, false};
}
inline LLMCompletionRequest StatusOr_LLMCompletionRequest::value() const {
  auto swig_cres = inworld_StatusOr_LLMCompletionRequest_value(swig_self());
  return LLMCompletionRequest{swig_cres, true};
}
inline StatusOr_LLMCompletionRequest::StatusOr_LLMCompletionRequest(StatusOr_LLMCompletionRequest const & other) : StatusOr_LLMCompletionRequest{inworld_StatusOr_LLMCompletionRequest_copy(other.swig_self())} {}
inline std::string BaseData::ToString() const {
  auto swig_cres = inworld_BaseData_ToString(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline bool BaseData::is_valid() const { return inworld_BaseData_is_valid(swig_self()); }
inline Text::Text() : Text{inworld_Text_new()} {}
inline Text::Text(std::string const& text) : Text{inworld_Text_new_std_string((&text)->c_str())} {}
inline std::string Text::value() const {
  auto swig_cres = inworld_Text_value(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline bool Text::is_valid() const { return inworld_Text_is_valid(swig_self()); }
inline Text::Text(std::string const& text, std::string const& arg2) : Text{inworld_Text_new_rcstd_string_rcstd_string((&text)->c_str(), (&arg2)->c_str())} {}
inline Text::Text(Text const & other) : Text{inworld_Text_copy(other.swig_self())} {}
inline Audio::Audio() : Audio{inworld_Audio_new()} {}
inline Audio::Audio(vector_float const& data, int arg2) : Audio{inworld_Audio_new_std_vector_Sl_float_Sg__i(data.swig_self(), arg2)} {}
inline vector_float Audio::data() const {
  auto swig_cres = inworld_Audio_data(swig_self());
  return vector_float{swig_cres, false};
}
inline int Audio::sample_rate() const { return inworld_Audio_sample_rate(swig_self()); }
inline bool Audio::is_valid() const { return inworld_Audio_is_valid(swig_self()); }
inline Audio::Audio(Audio const & other) : Audio{inworld_Audio_copy(other.swig_self())} {}
inline TTSOutput::TTSOutput(std::string const& text, Audio const& arg2) : TTSOutput{inworld_TTSOutput_new_std_string_std_shared_ptr_Sl_inworld_graphs_Audio_Sg_((&text)->c_str(), arg2.swig_self())} {}
inline void TTSOutput::text(std::string const& text) { inworld_TTSOutput_text_set(swig_self(), (&text)->c_str()); }
inline std::string TTSOutput::text() const {
  auto swig_cres = inworld_TTSOutput_text_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void TTSOutput::audio(Audio const& audio) { inworld_TTSOutput_audio_set(swig_self(), audio.swig_self()); }
inline Audio TTSOutput::audio() const {
  auto swig_cres = inworld_TTSOutput_audio_get(swig_self());
  return Audio{swig_cres, true};
}
inline Audio TTSOutput::safe_audio() const {
  auto swig_cres = inworld_TTSOutput_safe_audio(swig_self());
  return Audio{swig_cres, true};
}
inline TTSOutput::TTSOutput(TTSOutput const & other) : TTSOutput{inworld_TTSOutput_copy(other.swig_self())} {}
inline void PhraseMatch::phrase(std::string const& phrase) { inworld_PhraseMatch_phrase_set(swig_self(), (&phrase)->c_str()); }
inline std::string PhraseMatch::phrase() const {
  auto swig_cres = inworld_PhraseMatch_phrase_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void PhraseMatch::score(float score) { inworld_PhraseMatch_score_set(swig_self(), score); }
inline float PhraseMatch::score() const { return inworld_PhraseMatch_score_get(swig_self()); }
inline PhraseMatch::PhraseMatch() : PhraseMatch{inworld_PhraseMatch_new()} {}
inline PhraseMatch::PhraseMatch(PhraseMatch const & other) : PhraseMatch{inworld_PhraseMatch_copy(other.swig_self())} {}
inline SafetyResult::SafetyResult() : SafetyResult{inworld_SafetyResult_new()} {}
inline SafetyResult::SafetyResult(std::string const& text, bool arg2) : SafetyResult{inworld_SafetyResult_new_std_string_b((&text)->c_str(), arg2)} {}
inline bool SafetyResult::is_safe() const { return inworld_SafetyResult_is_safe(swig_self()); }
inline std::string SafetyResult::text() const {
  auto swig_cres = inworld_SafetyResult_text(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline bool SafetyResult::is_valid() const { return inworld_SafetyResult_is_valid(swig_self()); }
inline SafetyResult::SafetyResult(SafetyResult const & other) : SafetyResult{inworld_SafetyResult_copy(other.swig_self())} {}
inline MatchedKeywords::MatchedKeywords() : MatchedKeywords{inworld_MatchedKeywords_new()} {}
inline MatchedKeywords::MatchedKeywords(vector_KeywordMatch const& matches) : MatchedKeywords{inworld_MatchedKeywords_new_std_vector_Sl_inworld_KeywordMatch_Sg_(matches.swig_self())} {}
inline vector_KeywordMatch MatchedKeywords::matches() const {
  auto swig_cres = inworld_MatchedKeywords_matches(swig_self());
  return vector_KeywordMatch{swig_cres, false};
}
inline bool MatchedKeywords::is_valid() const { return inworld_MatchedKeywords_is_valid(swig_self()); }
inline MatchedKeywords::MatchedKeywords(MatchedKeywords const & other) : MatchedKeywords{inworld_MatchedKeywords_copy(other.swig_self())} {}
inline MatchedPhrases::MatchedPhrases() : MatchedPhrases{inworld_MatchedPhrases_new()} {}
inline MatchedPhrases::MatchedPhrases(vector_PhraseMatch const& phrase_matches) : MatchedPhrases{inworld_MatchedPhrases_new_std_vector_Sl_inworld_graphs_PhraseMatch_Sg_(phrase_matches.swig_self())} {}
inline vector_PhraseMatch MatchedPhrases::phrase_matches() const {
  auto swig_cres = inworld_MatchedPhrases_phrase_matches(swig_self());
  return vector_PhraseMatch{swig_cres, false};
}
inline bool MatchedPhrases::is_valid() const { return inworld_MatchedPhrases_is_valid(swig_self()); }
inline MatchedPhrases::MatchedPhrases(MatchedPhrases const & other) : MatchedPhrases{inworld_MatchedPhrases_copy(other.swig_self())} {}
inline ClassificationResult::ClassificationResult() : ClassificationResult{inworld_ClassificationResult_new()} {}
inline ClassificationResult::ClassificationResult(vector_string const& classes) : ClassificationResult{inworld_ClassificationResult_new_std_vector_Sl_std_string_Sg_(classes.swig_self())} {}
inline vector_string ClassificationResult::classes() const {
  auto swig_cres = inworld_ClassificationResult_classes(swig_self());
  return vector_string{swig_cres, false};
}
inline bool ClassificationResult::HasClasses() const { return inworld_ClassificationResult_HasClasses(swig_self()); }
inline bool ClassificationResult::is_valid() const { return inworld_ClassificationResult_is_valid(swig_self()); }
inline ClassificationResult::ClassificationResult(ClassificationResult const & other) : ClassificationResult{inworld_ClassificationResult_copy(other.swig_self())} {}
inline KnowledgeRecords::KnowledgeRecords() : KnowledgeRecords{inworld_KnowledgeRecords_new()} {}
inline KnowledgeRecords::KnowledgeRecords(vector_string const& records) : KnowledgeRecords{inworld_KnowledgeRecords_new_std_vector_Sl_std_string_Sg_(records.swig_self())} {}
inline vector_string KnowledgeRecords::records() const {
  auto swig_cres = inworld_KnowledgeRecords_records(swig_self());
  return vector_string{swig_cres, false};
}
inline bool KnowledgeRecords::is_valid() const { return inworld_KnowledgeRecords_is_valid(swig_self()); }
inline KnowledgeRecords::KnowledgeRecords(KnowledgeRecords const & other) : KnowledgeRecords{inworld_KnowledgeRecords_copy(other.swig_self())} {}
inline Error::Error() : Error{inworld_Error_new()} {}
inline Error::Error(Status const& status) : Error{inworld_Error_new_absl_Status(status.swig_self())} {}
inline Status Error::status() const {
  auto swig_cres = inworld_Error_status(swig_self());
  return Status{swig_cres, false};
}
inline bool Error::is_valid() const { return inworld_Error_is_valid(swig_self()); }
inline Error::Error(Error const & other) : Error{inworld_Error_copy(other.swig_self())} {}
inline MatchedIntents::MatchedIntents() : MatchedIntents{inworld_MatchedIntents_new()} {}
inline MatchedIntents::MatchedIntents(vector_IntentMatch const& intent_matches) : MatchedIntents{inworld_MatchedIntents_new_std_vector_Sl_inworld_IntentMatch_Sg_(intent_matches.swig_self())} {}
inline vector_IntentMatch MatchedIntents::intent_matches() const {
  auto swig_cres = inworld_MatchedIntents_intent_matches(swig_self());
  return vector_IntentMatch{swig_cres, false};
}
inline bool MatchedIntents::is_valid() const { return inworld_MatchedIntents_is_valid(swig_self()); }
inline MatchedIntents::MatchedIntents(MatchedIntents const & other) : MatchedIntents{inworld_MatchedIntents_copy(other.swig_self())} {}
inline GoalAdvancement::GoalAdvancement() : GoalAdvancement{inworld_GoalAdvancement_new()} {}
inline vector_string GoalAdvancement::activated_goals() const {
  auto swig_cres = inworld_GoalAdvancement_activated_goals(swig_self());
  return vector_string{swig_cres, false};
}
inline vector_string GoalAdvancement::completed_goals() const {
  auto swig_cres = inworld_GoalAdvancement_completed_goals(swig_self());
  return vector_string{swig_cres, false};
}
inline vector_string GoalAdvancement::current_goals() const {
  auto swig_cres = inworld_GoalAdvancement_current_goals(swig_self());
  return vector_string{swig_cres, false};
}
inline bool GoalAdvancement::is_valid() const { return inworld_GoalAdvancement_is_valid(swig_self()); }
inline GoalAdvancement::GoalAdvancement(GoalAdvancement const & other) : GoalAdvancement{inworld_GoalAdvancement_copy(other.swig_self())} {}
inline Json::Json() : Json{inworld_Json_new()} {}
inline bool Json::is_valid() const { return inworld_Json_is_valid(swig_self()); }
inline StatusOr_Json Json::inworld_inworld_graphs_Json_FromString__SWIG(std::string const& json_string) {
  auto swig_cres = inworld_Json_FromString((&json_string)->c_str());
  return StatusOr_Json{swig_cres, true};
}
inline std::string Json::value_as_string() const {
  auto swig_cres = inworld_Json_value_as_string(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline Json::Json(Json const & other) : Json{inworld_Json_copy(other.swig_self())} {}
inline ToolCallRequest::ToolCallRequest() : ToolCallRequest{inworld_ToolCallRequest_new()} {}
inline ToolCallRequest::ToolCallRequest(ToolCalls const& tool_calls) : ToolCallRequest{inworld_ToolCallRequest_new_std_vector_Sl_inworld_ToolCall_Sg_(tool_calls.swig_self())} {}
inline ToolCalls ToolCallRequest::tool_calls() const {
  auto swig_cres = inworld_ToolCallRequest_tool_calls(swig_self());
  return ToolCalls{swig_cres, false};
}
inline bool ToolCallRequest::is_valid() const { return inworld_ToolCallRequest_is_valid(swig_self()); }
inline ToolCallRequest::ToolCallRequest(ToolCallRequest const & other) : ToolCallRequest{inworld_ToolCallRequest_copy(other.swig_self())} {}
inline ListToolsResponse::ListToolsResponse() : ListToolsResponse{inworld_ListToolsResponse_new()} {}
inline ListToolsResponse::ListToolsResponse(Vector_Tool const& list_tools) : ListToolsResponse{inworld_ListToolsResponse_new_std_vector_Sl_inworld_Tool_Sg_(list_tools.swig_self())} {}
inline Vector_Tool ListToolsResponse::list_tools() const {
  auto swig_cres = inworld_ListToolsResponse_list_tools(swig_self());
  return Vector_Tool{swig_cres, false};
}
inline bool ListToolsResponse::is_valid() const { return inworld_ListToolsResponse_is_valid(swig_self()); }
inline ListToolsResponse::ListToolsResponse(ListToolsResponse const & other) : ListToolsResponse{inworld_ListToolsResponse_copy(other.swig_self())} {}
inline LLMChatRequest::LLMChatRequest() : LLMChatRequest{inworld_LLMChatRequest_new()} {}
inline LLMChatRequest::LLMChatRequest(Messages const& messages, Vector_Tool const& arg2, optional_ToolChoice const& arg3, ResponseFormat arg4, optional_TextGenerationConfig const& arg5) : LLMChatRequest{inworld_LLMChatRequest_new_std_vector_Sl_inworld_Message_Sg__std_vector_Sl_inworld_Tool_Sg__std_optional_Sl_inworld_ToolChoice_Sg__eResponseFormat_std_optional_Sl_inworld_TextGenerationConfig_Sg_(messages.swig_self(), arg2.swig_self(), arg3.swig_self(), (inworld_ResponseFormat)arg4, arg5.swig_self())} {}
inline LLMChatRequest::LLMChatRequest(Messages const& messages, Vector_Tool const& arg2, optional_ToolChoice const& arg3, ResponseFormat arg4) : LLMChatRequest{inworld_LLMChatRequest_new_std_vector_Sl_inworld_Message_Sg__std_vector_Sl_inworld_Tool_Sg__std_optional_Sl_inworld_ToolChoice_Sg__eResponseFormat(messages.swig_self(), arg2.swig_self(), arg3.swig_self(), (inworld_ResponseFormat)arg4)} {}
inline LLMChatRequest::LLMChatRequest(Messages const& messages, Vector_Tool const& arg2, optional_ToolChoice const& arg3) : LLMChatRequest{inworld_LLMChatRequest_new_std_vector_Sl_inworld_Message_Sg__std_vector_Sl_inworld_Tool_Sg__std_optional_Sl_inworld_ToolChoice_Sg_(messages.swig_self(), arg2.swig_self(), arg3.swig_self())} {}
inline LLMChatRequest::LLMChatRequest(Messages const& messages, Vector_Tool const& arg2) : LLMChatRequest{inworld_LLMChatRequest_new_std_vector_Sl_inworld_Message_Sg__std_vector_Sl_inworld_Tool_Sg_(messages.swig_self(), arg2.swig_self())} {}
inline LLMChatRequest::LLMChatRequest(Messages const& messages) : LLMChatRequest{inworld_LLMChatRequest_new_std_vector_Sl_inworld_Message_Sg_(messages.swig_self())} {}
inline Messages LLMChatRequest::messages() const {
  auto swig_cres = inworld_LLMChatRequest_messages(swig_self());
  return Messages{swig_cres, false};
}
inline Vector_Tool LLMChatRequest::tools() const {
  auto swig_cres = inworld_LLMChatRequest_tools(swig_self());
  return Vector_Tool{swig_cres, false};
}
inline optional_ToolChoice LLMChatRequest::tool_choice() const {
  auto swig_cres = inworld_LLMChatRequest_tool_choice(swig_self());
  return optional_ToolChoice{swig_cres, false};
}
inline ResponseFormat LLMChatRequest::response_format() const {
  auto swig_cres = inworld_LLMChatRequest_response_format(swig_self());
  return (ResponseFormat)swig_cres;
}
inline optional_TextGenerationConfig LLMChatRequest::text_generation_config() const {
  auto swig_cres = inworld_LLMChatRequest_text_generation_config(swig_self());
  return optional_TextGenerationConfig{swig_cres, false};
}
inline bool LLMChatRequest::is_valid() const { return inworld_LLMChatRequest_is_valid(swig_self()); }
inline LLMChatRequest::LLMChatRequest(LLMChatRequest const & other) : LLMChatRequest{inworld_LLMChatRequest_copy(other.swig_self())} {}
inline LLMChatResponse::LLMChatResponse() : LLMChatResponse{inworld_LLMChatResponse_new()} {}
inline LLMChatResponse::LLMChatResponse(Content const& response) : LLMChatResponse{inworld_LLMChatResponse_new_inworld_Content(response.swig_self())} {}
inline bool LLMChatResponse::is_streaming() const { return inworld_LLMChatResponse_is_streaming(swig_self()); }
inline bool LLMChatResponse::is_valid() const { return inworld_LLMChatResponse_is_valid(swig_self()); }
inline bool LLMChatResponse::has_complete_content() const { return inworld_LLMChatResponse_has_complete_content(swig_self()); }
inline Content LLMChatResponse::get_response_content() const {
  auto swig_cres = inworld_LLMChatResponse_get_response_content(swig_self());
  return Content{swig_cres, true};
}
inline InputStream_Content LLMChatResponse::get_response_stream() const {
  auto swig_cres = inworld_LLMChatResponse_get_response_stream(swig_self());
  return InputStream_Content{swig_cres, true};
}
inline LLMChatResponse::LLMChatResponse(LLMChatResponse const & other) : LLMChatResponse{inworld_LLMChatResponse_copy(other.swig_self())} {}
inline LLMCompletionRequest::LLMCompletionRequest() : LLMCompletionRequest{inworld_LLMCompletionRequest_new()} {}
inline LLMCompletionRequest::LLMCompletionRequest(std::string const& text, optional_TextGenerationConfig const& arg2) : LLMCompletionRequest{inworld_LLMCompletionRequest_new_std_string_std_optional_Sl_inworld_TextGenerationConfig_Sg_((&text)->c_str(), arg2.swig_self())} {}
inline LLMCompletionRequest::LLMCompletionRequest(std::string const& text) : LLMCompletionRequest{inworld_LLMCompletionRequest_new_std_string((&text)->c_str())} {}
inline std::string LLMCompletionRequest::text() const {
  auto swig_cres = inworld_LLMCompletionRequest_text(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline optional_TextGenerationConfig LLMCompletionRequest::text_generation_config() const {
  auto swig_cres = inworld_LLMCompletionRequest_text_generation_config(swig_self());
  return optional_TextGenerationConfig{swig_cres, false};
}
inline bool LLMCompletionRequest::is_valid() const { return inworld_LLMCompletionRequest_is_valid(swig_self()); }
inline LLMCompletionRequest::LLMCompletionRequest(LLMCompletionRequest const & other) : LLMCompletionRequest{inworld_LLMCompletionRequest_copy(other.swig_self())} {}
inline LLMCompletionResponse::LLMCompletionResponse() : LLMCompletionResponse{inworld_LLMCompletionResponse_new()} {}
inline LLMCompletionResponse::LLMCompletionResponse(std::string const& response) : LLMCompletionResponse{inworld_LLMCompletionResponse_new_std_string((&response)->c_str())} {}
inline bool LLMCompletionResponse::is_streaming() const { return inworld_LLMCompletionResponse_is_streaming(swig_self()); }
inline bool LLMCompletionResponse::is_valid() const { return inworld_LLMCompletionResponse_is_valid(swig_self()); }
inline bool LLMCompletionResponse::has_complete_content() const { return inworld_LLMCompletionResponse_has_complete_content(swig_self()); }
inline std::string LLMCompletionResponse::get_content_text() const {
  auto swig_cres = inworld_LLMCompletionResponse_get_content_text(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline InputStream_string LLMCompletionResponse::get_input_stream() const {
  auto swig_cres = inworld_LLMCompletionResponse_get_input_stream(swig_self());
  return InputStream_string{swig_cres, true};
}
inline LLMCompletionResponse::LLMCompletionResponse(LLMCompletionResponse const & other) : LLMCompletionResponse{inworld_LLMCompletionResponse_copy(other.swig_self())} {}
inline ToolCallResult::ToolCallResult() : ToolCallResult{inworld_ToolCallResult_new()} {}
inline ToolCallResult::ToolCallResult(std::string const& tool_call_id, std::string const& arg2) : ToolCallResult{inworld_ToolCallResult_new_std_string_std_string((&tool_call_id)->c_str(), (&arg2)->c_str())} {}
inline std::string ToolCallResult::tool_call_id() const {
  auto swig_cres = inworld_ToolCallResult_tool_call_id(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline std::string ToolCallResult::result() const {
  auto swig_cres = inworld_ToolCallResult_result(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline bool ToolCallResult::is_valid() const { return inworld_ToolCallResult_is_valid(swig_self()); }
inline ToolCallResult::ToolCallResult(ToolCallResult const & other) : ToolCallResult{inworld_ToolCallResult_copy(other.swig_self())} {}
inline ToolCallResponse::ToolCallResponse() : ToolCallResponse{inworld_ToolCallResponse_new()} {}
inline bool ToolCallResponse::is_valid() const { return inworld_ToolCallResponse_is_valid(swig_self()); }
inline ToolCallResponse::ToolCallResponse(vector_ToolCallResult const& tool_calls_results) : ToolCallResponse{inworld_ToolCallResponse_new_std_vector_Sl_std_shared_ptr_Sl_inworld_graphs_ToolCallResult_Sg__Sg_(tool_calls_results.swig_self())} {}
inline vector_ToolCallResult ToolCallResponse::tool_call_results_swig() const {
  auto swig_cres = inworld_ToolCallResponse_tool_call_results_swig(swig_self());
  return vector_ToolCallResult{swig_cres, true};
}
inline ToolCallResponse::ToolCallResponse(ToolCallResponse const & other) : ToolCallResponse{inworld_ToolCallResponse_copy(other.swig_self())} {}
inline TTSRequest::TTSRequest() : TTSRequest{inworld_TTSRequest_new()} {}
inline optional_Voice TTSRequest::voice() const {
  auto swig_cres = inworld_TTSRequest_voice(swig_self());
  return optional_Voice{swig_cres, false};
}
inline optional_SpeechSynthesisConfig TTSRequest::synthesis_config() const {
  auto swig_cres = inworld_TTSRequest_synthesis_config(swig_self());
  return optional_SpeechSynthesisConfig{swig_cres, false};
}
inline bool TTSRequest::is_valid() const { return inworld_TTSRequest_is_valid(swig_self()); }
inline TTSRequest::TTSRequest(Text const& text, optional_Voice const& arg2, optional_SpeechSynthesisConfig const& arg3) : TTSRequest{inworld_TTSRequest_new_std_shared_ptr_Sl_inworld_graphs_Text_Sg__std_optional_Sl_inworld_Voice_Sg__std_optional_Sl_inworld_SpeechSynthesisConfig_Sg_(text.swig_self(), arg2.swig_self(), arg3.swig_self())} {}
inline TTSRequest::TTSRequest(Text const& text, optional_Voice const& arg2) : TTSRequest{inworld_TTSRequest_new_std_shared_ptr_Sl_inworld_graphs_Text_Sg__std_optional_Sl_inworld_Voice_Sg_(text.swig_self(), arg2.swig_self())} {}
inline TTSRequest::TTSRequest(std::string const& text_content, optional_Voice const& arg2, optional_SpeechSynthesisConfig const& arg3) : TTSRequest{inworld_TTSRequest_new_rcstd_string_std_optional_Sl_inworld_Voice_Sg__std_optional_Sl_inworld_SpeechSynthesisConfig_Sg_((&text_content)->c_str(), arg2.swig_self(), arg3.swig_self())} {}
inline TTSRequest::TTSRequest(std::string const& text_content, optional_Voice const& arg2) : TTSRequest{inworld_TTSRequest_new_rcstd_string_std_optional_Sl_inworld_Voice_Sg_((&text_content)->c_str(), arg2.swig_self())} {}
inline TTSRequest::TTSRequest(DataStream_String const& stream, optional_Voice const& arg2, optional_SpeechSynthesisConfig const& arg3) : TTSRequest{inworld_TTSRequest_new_std_shared_ptr_Sl_inworld_graphs_DataStream_Sl_std_string_Sg__Sg__std_optional_Sl_inworld_Voice_Sg__std_optional_Sl_inworld_SpeechSynthesisConfig_Sg_(stream.swig_self(), arg2.swig_self(), arg3.swig_self())} {}
inline TTSRequest::TTSRequest(DataStream_String const& stream, optional_Voice const& arg2) : TTSRequest{inworld_TTSRequest_new_std_shared_ptr_Sl_inworld_graphs_DataStream_Sl_std_string_Sg__Sg__std_optional_Sl_inworld_Voice_Sg_(stream.swig_self(), arg2.swig_self())} {}
inline bool TTSRequest::has_text_content() const { return inworld_TTSRequest_has_text_content(swig_self()); }
inline bool TTSRequest::has_stream_content() const { return inworld_TTSRequest_has_stream_content(swig_self()); }
inline Text TTSRequest::get_text_content() const {
  auto swig_cres = inworld_TTSRequest_get_text_content(swig_self());
  return Text{swig_cres, true};
}
inline InputStream_string TTSRequest::get_content_stream() const {
  auto swig_cres = inworld_TTSRequest_get_content_stream(swig_self());
  return InputStream_string{swig_cres, true};
}
inline optional_Voice TTSRequest::get_voice() const {
  auto swig_cres = inworld_TTSRequest_get_voice(swig_self());
  return optional_Voice{swig_cres, true};
}
inline optional_SpeechSynthesisConfig TTSRequest::get_synthesis_config() const {
  auto swig_cres = inworld_TTSRequest_get_synthesis_config(swig_self());
  return optional_SpeechSynthesisConfig{swig_cres, true};
}
inline TTSRequest::TTSRequest(TTSRequest const & other) : TTSRequest{inworld_TTSRequest_copy(other.swig_self())} {}
inline STTRequest::STTRequest() : STTRequest{inworld_STTRequest_new()} {}
inline optional_SpeechRecognitionConfig STTRequest::speech_recognition_config() const {
  auto swig_cres = inworld_STTRequest_speech_recognition_config(swig_self());
  return optional_SpeechRecognitionConfig{swig_cres, false};
}
inline bool STTRequest::is_valid() const { return inworld_STTRequest_is_valid(swig_self()); }
inline STTRequest::STTRequest(Audio const& audio, optional_SpeechRecognitionConfig const& arg2) : STTRequest{inworld_STTRequest_new_std_shared_ptr_Sl_inworld_graphs_Audio_Sg__std_optional_Sl_inworld_SpeechRecognitionConfig_Sg_(audio.swig_self(), arg2.swig_self())} {}
inline STTRequest::STTRequest(Audio const& audio) : STTRequest{inworld_STTRequest_new_std_shared_ptr_Sl_inworld_graphs_Audio_Sg_(audio.swig_self())} {}
inline STTRequest::STTRequest(DataStream_AudioChunk const& stream, optional_SpeechRecognitionConfig const& arg2) : STTRequest{inworld_STTRequest_new_std_shared_ptr_Sl_inworld_graphs_DataStream_Sl_inworld_AudioChunk_Sg__Sg__std_optional_Sl_inworld_SpeechRecognitionConfig_Sg_(stream.swig_self(), arg2.swig_self())} {}
inline STTRequest::STTRequest(DataStream_AudioChunk const& stream) : STTRequest{inworld_STTRequest_new_std_shared_ptr_Sl_inworld_graphs_DataStream_Sl_inworld_AudioChunk_Sg__Sg_(stream.swig_self())} {}
inline bool STTRequest::has_audio_content() const { return inworld_STTRequest_has_audio_content(swig_self()); }
inline bool STTRequest::has_stream_content() const { return inworld_STTRequest_has_stream_content(swig_self()); }
inline Audio STTRequest::get_audio_content() const {
  auto swig_cres = inworld_STTRequest_get_audio_content(swig_self());
  return Audio{swig_cres, true};
}
inline InputStream_AudioChunk STTRequest::get_content_stream() const {
  auto swig_cres = inworld_STTRequest_get_content_stream(swig_self());
  return InputStream_AudioChunk{swig_cres, true};
}
inline optional_SpeechRecognitionConfig STTRequest::get_speech_recognition_config() const {
  auto swig_cres = inworld_STTRequest_get_speech_recognition_config(swig_self());
  return optional_SpeechRecognitionConfig{swig_cres, true};
}
inline STTRequest::STTRequest(STTRequest const & other) : STTRequest{inworld_STTRequest_copy(other.swig_self())} {}
inline CustomDataToJsonExecutor::CustomDataToJsonExecutor(void * custom_data, void * arg2) : CustomDataToJsonExecutor{inworld_CustomDataToJsonExecutor_new_pv_pv(custom_data, arg2)} {}
inline void CustomDataToJsonExecutor::SetNextOutput(std::string const& text) { inworld_CustomDataToJsonExecutor_SetNextOutput((&text)->c_str()); }
inline CustomDataToJsonExecutor::CustomDataToJsonExecutor(CustomDataToJsonExecutor const & other) : CustomDataToJsonExecutor{inworld_CustomDataToJsonExecutor_copy(other.swig_self())} {}
inline CustomDataDestructor::CustomDataDestructor(void * custom_data, void * arg2) : CustomDataDestructor{inworld_CustomDataDestructor_new_pv_pv(custom_data, arg2)} {}
inline CustomDataDestructor::CustomDataDestructor(CustomDataDestructor const & other) : CustomDataDestructor{inworld_CustomDataDestructor_copy(other.swig_self())} {}
inline CustomDataWrapper::CustomDataWrapper(const char * type_id, void * arg2, CustomDataToJsonExecutor const & arg3, CustomDataDestructor const & arg4) : CustomDataWrapper{inworld_CustomDataWrapper_new_pcc_pv_rcinworld_swig_helpers_CustomDataToJsonExecutor_rcinworld_swig_helpers_CustomDataDestructor(type_id, arg2, arg3.swig_self(), arg4.swig_self())} {}
inline const char * CustomDataWrapper::type_id() const { return inworld_CustomDataWrapper_type_id(swig_self()); }
inline void * CustomDataWrapper::value() const { return inworld_CustomDataWrapper_value(swig_self()); }
inline bool CustomDataWrapper::is_valid() const { return inworld_CustomDataWrapper_is_valid(swig_self()); }
inline CustomDataWrapper::CustomDataWrapper(CustomDataWrapper const & other) : CustomDataWrapper{inworld_CustomDataWrapper_copy(other.swig_self())} {}
inline Error BaseDataAs_Error(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_Error(base_data.swig_self());
  return Error{swig_cres, true};
}
inline Text BaseDataAs_Text(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_Text(base_data.swig_self());
  return Text{swig_cres, true};
}
inline Audio BaseDataAs_Audio(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_Audio(base_data.swig_self());
  return Audio{swig_cres, true};
}
inline MatchedIntents BaseDataAs_MatchedIntents(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_MatchedIntents(base_data.swig_self());
  return MatchedIntents{swig_cres, true};
}
inline MatchedKeywords BaseDataAs_MatchedKeywords(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_MatchedKeywords(base_data.swig_self());
  return MatchedKeywords{swig_cres, true};
}
inline MatchedPhrases BaseDataAs_MatchedPhrases(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_MatchedPhrases(base_data.swig_self());
  return MatchedPhrases{swig_cres, true};
}
inline ClassificationResult BaseDataAs_ClassificationResult(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_ClassificationResult(base_data.swig_self());
  return ClassificationResult{swig_cres, true};
}
inline GoalAdvancement BaseDataAs_GoalAdvancement(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_GoalAdvancement(base_data.swig_self());
  return GoalAdvancement{swig_cres, true};
}
inline KnowledgeRecords BaseDataAs_KnowledgeRecords(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_KnowledgeRecords(base_data.swig_self());
  return KnowledgeRecords{swig_cres, true};
}
inline Json BaseDataAs_Json(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_Json(base_data.swig_self());
  return Json{swig_cres, true};
}
inline MemoryState BaseDataAs_MemoryState(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_MemoryState(base_data.swig_self());
  return MemoryState{swig_cres, true};
}
inline LLMChatRequest BaseDataAs_LLMChatRequest(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_LLMChatRequest(base_data.swig_self());
  return LLMChatRequest{swig_cres, true};
}
inline LLMChatResponse BaseDataAs_LLMChatResponse(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_LLMChatResponse(base_data.swig_self());
  return LLMChatResponse{swig_cres, true};
}
inline LLMCompletionResponse BaseDataAs_LLMCompletionResponse(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_LLMCompletionResponse(base_data.swig_self());
  return LLMCompletionResponse{swig_cres, true};
}
inline SafetyResult BaseDataAs_SafetyResult(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_SafetyResult(base_data.swig_self());
  return SafetyResult{swig_cres, true};
}
inline TTSRequest BaseDataAs_TTSRequest(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_TTSRequest(base_data.swig_self());
  return TTSRequest{swig_cres, true};
}
inline STTRequest BaseDataAs_STTRequest(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_STTRequest(base_data.swig_self());
  return STTRequest{swig_cres, true};
}
inline CustomDataWrapper BaseDataAs_CustomDataWrapper(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_CustomDataWrapper(base_data.swig_self());
  return CustomDataWrapper{swig_cres, true};
}
inline ListToolsResponse BaseDataAs_ListToolsResponse(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_ListToolsResponse(base_data.swig_self());
  return ListToolsResponse{swig_cres, true};
}
inline ToolCallRequest BaseDataAs_ToolCallRequest(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_ToolCallRequest(base_data.swig_self());
  return ToolCallRequest{swig_cres, true};
}
inline ToolCallResult BaseDataAs_ToolCallResult(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_ToolCallResult(base_data.swig_self());
  return ToolCallResult{swig_cres, true};
}
inline ToolCallResponse BaseDataAs_ToolCallResponse(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_ToolCallResponse(base_data.swig_self());
  return ToolCallResponse{swig_cres, true};
}
inline std::string type_id(BaseData const * base_data) {
  auto swig_cres = inworld_type_id(base_data->swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline StatusOr_BaseData::StatusOr_BaseData() : StatusOr_BaseData{inworld_StatusOr_BaseData_new()} {}
inline StatusOr_BaseData::StatusOr_BaseData(BaseData const& value) : StatusOr_BaseData{inworld_StatusOr_BaseData_new_rcstd_shared_ptr_Sl_inworld_graphs_BaseData_Sg_(value.swig_self())} {}
inline StatusOr_BaseData::StatusOr_BaseData(Status const & status) : StatusOr_BaseData{inworld_StatusOr_BaseData_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_BaseData::ok() const { return inworld_StatusOr_BaseData_ok(swig_self()); }
inline Status StatusOr_BaseData::status() const {
  auto swig_cres = inworld_StatusOr_BaseData_status(swig_self());
  return Status{swig_cres, false};
}
inline BaseData StatusOr_BaseData::value() const {
  auto swig_cres = inworld_StatusOr_BaseData_value(swig_self());
  return BaseData{swig_cres, true};
}
inline StatusOr_BaseData::StatusOr_BaseData(StatusOr_BaseData const & other) : StatusOr_BaseData{inworld_StatusOr_BaseData_copy(other.swig_self())} {}
inline std::string Node::id() const {
  auto swig_cres = inworld_Node_id(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline StatusOr_BaseData Node::Process(ProcessContext & ctx, vector_BaseData const & arg3) const {
  auto swig_cres = inworld_Node_Process(swig_self(), ctx.swig_self(), arg3.swig_self());
  return StatusOr_BaseData{swig_cres, true};
}
inline bool Node::is_valid() const { return inworld_Node_is_valid(swig_self()); }
inline bool TypedNodeBase::is_valid() const { return inworld_TypedNodeBase_is_valid(swig_self()); }
inline CustomNodeProcessExecutor::CustomNodeProcessExecutor(void * custom_node, void * arg2) : CustomNodeProcessExecutor{inworld_CustomNodeProcessExecutor_new_pv_pv(custom_node, arg2)} {}
inline vector_BaseData CustomNodeProcessExecutor::GetLastInputs() {
  auto swig_cres = inworld_CustomNodeProcessExecutor_GetLastInputs();
  return vector_BaseData{swig_cres, true};
}
inline ProcessContext CustomNodeProcessExecutor::GetLastContext() {
  auto swig_cres = inworld_CustomNodeProcessExecutor_GetLastContext();
  return ProcessContext{swig_cres, false};
}
inline void CustomNodeProcessExecutor::SetLastOutput(StatusOr_BaseData const& output) { inworld_CustomNodeProcessExecutor_SetLastOutput(output.swig_self()); }
inline CustomNodeProcessExecutor::CustomNodeProcessExecutor(CustomNodeProcessExecutor const & other) : CustomNodeProcessExecutor{inworld_CustomNodeProcessExecutor_copy(other.swig_self())} {}
inline CustomNodeThreadedProcessExecutor::CustomNodeThreadedProcessExecutor(void * custom_node, void * arg2) : CustomNodeThreadedProcessExecutor{inworld_CustomNodeThreadedProcessExecutor_new_pv_pv(custom_node, arg2)} {}
inline vector_BaseData CustomNodeThreadedProcessExecutor::GetInputs(int execution_id) {
  auto swig_cres = inworld_CustomNodeThreadedProcessExecutor_GetInputs(execution_id);
  return vector_BaseData{swig_cres, true};
}
inline ProcessContext CustomNodeThreadedProcessExecutor::GetContext(int execution_id) {
  auto swig_cres = inworld_CustomNodeThreadedProcessExecutor_GetContext(execution_id);
  return ProcessContext{swig_cres, false};
}
inline void CustomNodeThreadedProcessExecutor::SetOutput(int execution_id, StatusOr_BaseData const& arg2) { inworld_CustomNodeThreadedProcessExecutor_SetOutput(execution_id, arg2.swig_self()); }
inline CustomNodeThreadedProcessExecutor::CustomNodeThreadedProcessExecutor(CustomNodeThreadedProcessExecutor const & other) : CustomNodeThreadedProcessExecutor{inworld_CustomNodeThreadedProcessExecutor_copy(other.swig_self())} {}
inline CustomNodeDestructor::CustomNodeDestructor(void * context, void * arg2) : CustomNodeDestructor{inworld_CustomNodeDestructor_new_pv_pv(context, arg2)} {}
inline CustomNodeDestructor::CustomNodeDestructor(CustomNodeDestructor const & other) : CustomNodeDestructor{inworld_CustomNodeDestructor_copy(other.swig_self())} {}
inline CustomNodeWrapper::CustomNodeWrapper(std::string const& id, CustomNodeProcessExecutor const & arg2) : CustomNodeWrapper{inworld_CustomNodeWrapper_new_rcstd_string_rcinworld_swig_helpers_CustomNodeProcessExecutor((&id)->c_str(), arg2.swig_self())} {}
inline CustomNodeWrapper::CustomNodeWrapper(std::string const& id, CustomNodeThreadedProcessExecutor const & arg2) : CustomNodeWrapper{inworld_CustomNodeWrapper_new_rcstd_string_rcinworld_swig_helpers_CustomNodeThreadedProcessExecutor((&id)->c_str(), arg2.swig_self())} {}
inline CustomNodeWrapper::CustomNodeWrapper(std::string const& id, CustomNodeProcessExecutor const & arg2, CustomNodeDestructor const & arg3) : CustomNodeWrapper{inworld_CustomNodeWrapper_new_rcstd_string_rcinworld_swig_helpers_CustomNodeProcessExecutor_rcinworld_swig_helpers_CustomNodeDestructor((&id)->c_str(), arg2.swig_self(), arg3.swig_self())} {}
inline CustomNodeWrapper::CustomNodeWrapper(std::string const& id, CustomNodeThreadedProcessExecutor const & arg2, CustomNodeDestructor const & arg3) : CustomNodeWrapper{inworld_CustomNodeWrapper_new_rcstd_string_rcinworld_swig_helpers_CustomNodeThreadedProcessExecutor_rcinworld_swig_helpers_CustomNodeDestructor((&id)->c_str(), arg2.swig_self(), arg3.swig_self())} {}
inline CustomNodeWrapper::CustomNodeWrapper(std::string const& id, NodeExecutionConfig const& arg2, CustomNodeProcessExecutor const & arg3) : CustomNodeWrapper{inworld_CustomNodeWrapper_new_rcstd_string_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg__rcinworld_swig_helpers_CustomNodeProcessExecutor((&id)->c_str(), arg2.swig_self(), arg3.swig_self())} {}
inline CustomNodeWrapper::CustomNodeWrapper(std::string const& id, NodeExecutionConfig const& arg2, CustomNodeThreadedProcessExecutor const & arg3) : CustomNodeWrapper{inworld_CustomNodeWrapper_new_rcstd_string_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg__rcinworld_swig_helpers_CustomNodeThreadedProcessExecutor((&id)->c_str(), arg2.swig_self(), arg3.swig_self())} {}
inline CustomNodeWrapper::CustomNodeWrapper(std::string const& id, NodeExecutionConfig const& arg2, CustomNodeProcessExecutor const & arg3, CustomNodeDestructor const & arg4) : CustomNodeWrapper{inworld_CustomNodeWrapper_new_rcstd_string_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg__rcinworld_swig_helpers_CustomNodeProcessExecutor_rcinworld_swig_helpers_CustomNodeDestructor((&id)->c_str(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self())} {}
inline CustomNodeWrapper::CustomNodeWrapper(std::string const& id, NodeExecutionConfig const& arg2, CustomNodeThreadedProcessExecutor const & arg3, CustomNodeDestructor const & arg4) : CustomNodeWrapper{inworld_CustomNodeWrapper_new_rcstd_string_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg__rcinworld_swig_helpers_CustomNodeThreadedProcessExecutor_rcinworld_swig_helpers_CustomNodeDestructor((&id)->c_str(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self())} {}
inline bool CustomNodeWrapper::is_valid() const { return inworld_CustomNodeWrapper_is_valid(swig_self()); }
inline CustomNodeWrapper::CustomNodeWrapper(CustomNodeWrapper const & other) : CustomNodeWrapper{inworld_CustomNodeWrapper_copy(other.swig_self())} {}
inline HashSet_String::HashSet_String() : HashSet_String{inworld_HashSet_String_new()} {}
inline size_t HashSet_String::size() const { return inworld_HashSet_String_size(swig_self()); }
inline bool HashSet_String::empty() const { return inworld_HashSet_String_empty(swig_self()); }
inline void HashSet_String::clear() { inworld_HashSet_String_clear(swig_self()); }
inline bool HashSet_String::__contains__(std::string const& key) { return inworld_HashSet_String___contains__(swig_self(), (&key)->c_str()); }
inline void HashSet_String::add(std::string const& key) { inworld_HashSet_String_add(swig_self(), (&key)->c_str()); }
inline HashSet_String::HashSet_String(HashSet_String const & other) : HashSet_String{inworld_HashSet_String_copy(other.swig_self())} {}
inline HashMap_StringToHashSetString::HashMap_StringToHashSetString() : HashMap_StringToHashSetString{inworld_HashMap_StringToHashSetString_new()} {}
inline size_t HashMap_StringToHashSetString::size() const { return inworld_HashMap_StringToHashSetString_size(swig_self()); }
inline bool HashMap_StringToHashSetString::empty() const { return inworld_HashMap_StringToHashSetString_empty(swig_self()); }
inline void HashMap_StringToHashSetString::clear() { inworld_HashMap_StringToHashSetString_clear(swig_self()); }
inline HashSet_String HashMap_StringToHashSetString::__getitem__(std::string const& key) {
  auto swig_cres = inworld_HashMap_StringToHashSetString___getitem__(swig_self(), (&key)->c_str());
  return HashSet_String{swig_cres, false};
}
inline void HashMap_StringToHashSetString::__setitem__(std::string const& key, HashSet_String const & arg3) { inworld_HashMap_StringToHashSetString___setitem__(swig_self(), (&key)->c_str(), arg3.swig_self()); }
inline bool HashMap_StringToHashSetString::__contains__(std::string const& key) { return inworld_HashMap_StringToHashSetString___contains__(swig_self(), (&key)->c_str()); }
inline HashMap_StringToHashSetString::HashMap_StringToHashSetString(HashMap_StringToHashSetString const & other) : HashMap_StringToHashSetString{inworld_HashMap_StringToHashSetString_copy(other.swig_self())} {}
inline void Edge::to_node_id(std::string const& to_node_id) { inworld_Edge_to_node_id_set(swig_self(), (&to_node_id)->c_str()); }
inline std::string Edge::to_node_id() const {
  auto swig_cres = inworld_Edge_to_node_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Edge::is_required(bool is_required) { inworld_Edge_is_required_set(swig_self(), is_required); }
inline bool Edge::is_required() const { return inworld_Edge_is_required_get(swig_self()); }
inline void Edge::is_loop_edge(bool is_loop_edge) { inworld_Edge_is_loop_edge_set(swig_self(), is_loop_edge); }
inline bool Edge::is_loop_edge() const { return inworld_Edge_is_loop_edge_get(swig_self()); }
inline Edge::Edge() : Edge{inworld_Edge_new()} {}
inline Edge::Edge(Edge const & other) : Edge{inworld_Edge_copy(other.swig_self())} {}
inline void Loop::entry_node_id(std::string const& entry_node_id) { inworld_Loop_entry_node_id_set(swig_self(), (&entry_node_id)->c_str()); }
inline std::string Loop::entry_node_id() const {
  auto swig_cres = inworld_Loop_entry_node_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Loop::loop_paths(HashMap_StringToHashSetString * loop_paths) { inworld_Loop_loop_paths_set(swig_self(), loop_paths->swig_self()); }
inline HashMap_StringToHashSetString * Loop::loop_paths() const {
  auto swig_cres = inworld_Loop_loop_paths_get(swig_self());
  return swig_cres ? new HashMap_StringToHashSetString(swig_cres, false) : nullptr;
}
inline Loop::Loop() : Loop{inworld_Loop_new()} {}
inline Loop::Loop(Loop const & other) : Loop{inworld_Loop_copy(other.swig_self())} {}
inline HashMap_StringToNode::HashMap_StringToNode() : HashMap_StringToNode{inworld_HashMap_StringToNode_new()} {}
inline size_t HashMap_StringToNode::size() const { return inworld_HashMap_StringToNode_size(swig_self()); }
inline bool HashMap_StringToNode::empty() const { return inworld_HashMap_StringToNode_empty(swig_self()); }
inline void HashMap_StringToNode::clear() { inworld_HashMap_StringToNode_clear(swig_self()); }
inline Node HashMap_StringToNode::__getitem__(std::string const& key) {
  auto swig_cres = inworld_HashMap_StringToNode___getitem__(swig_self(), (&key)->c_str());
  return Node{swig_cres, false};
}
inline void HashMap_StringToNode::__setitem__(std::string const& key, Node const& arg3) { inworld_HashMap_StringToNode___setitem__(swig_self(), (&key)->c_str(), arg3.swig_self()); }
inline bool HashMap_StringToNode::__contains__(std::string const& key) { return inworld_HashMap_StringToNode___contains__(swig_self(), (&key)->c_str()); }
inline HashMap_StringToNode::HashMap_StringToNode(HashMap_StringToNode const & other) : HashMap_StringToNode{inworld_HashMap_StringToNode_copy(other.swig_self())} {}
inline HashMap_StringToLoop::HashMap_StringToLoop() : HashMap_StringToLoop{inworld_HashMap_StringToLoop_new()} {}
inline size_t HashMap_StringToLoop::size() const { return inworld_HashMap_StringToLoop_size(swig_self()); }
inline bool HashMap_StringToLoop::empty() const { return inworld_HashMap_StringToLoop_empty(swig_self()); }
inline void HashMap_StringToLoop::clear() { inworld_HashMap_StringToLoop_clear(swig_self()); }
inline Loop HashMap_StringToLoop::__getitem__(std::string const& key) {
  auto swig_cres = inworld_HashMap_StringToLoop___getitem__(swig_self(), (&key)->c_str());
  return Loop{swig_cres, false};
}
inline void HashMap_StringToLoop::__setitem__(std::string const& key, Loop const & arg3) { inworld_HashMap_StringToLoop___setitem__(swig_self(), (&key)->c_str(), arg3.swig_self()); }
inline bool HashMap_StringToLoop::__contains__(std::string const& key) { return inworld_HashMap_StringToLoop___contains__(swig_self(), (&key)->c_str()); }
inline HashMap_StringToLoop::HashMap_StringToLoop(HashMap_StringToLoop const & other) : HashMap_StringToLoop{inworld_HashMap_StringToLoop_copy(other.swig_self())} {}
inline std::string CompiledGraphInterface::id() const {
  auto swig_cres = inworld_CompiledGraphInterface_id(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline HashMap_StringToNode CompiledGraphInterface::Nodes() const {
  auto swig_cres = inworld_CompiledGraphInterface_Nodes(swig_self());
  return HashMap_StringToNode{swig_cres, false};
}
inline HashSet_String CompiledGraphInterface::StartNodes() const {
  auto swig_cres = inworld_CompiledGraphInterface_StartNodes(swig_self());
  return HashSet_String{swig_cres, false};
}
inline HashSet_String CompiledGraphInterface::EndNodes() const {
  auto swig_cres = inworld_CompiledGraphInterface_EndNodes(swig_self());
  return HashSet_String{swig_cres, false};
}
inline HashMap_StringToLoop CompiledGraphInterface::Loops() const {
  auto swig_cres = inworld_CompiledGraphInterface_Loops(swig_self());
  return HashMap_StringToLoop{swig_cres, false};
}
inline vector_Edge CompiledGraphInterface::Edges(std::string const& node_id) const {
  auto swig_cres = inworld_CompiledGraphInterface_Edges(swig_self(), (&node_id)->c_str());
  return vector_Edge{swig_cres, false};
}
inline vector_string CompiledGraphInterface::ParentNodeIds(std::string const& node_id) const {
  auto swig_cres = inworld_CompiledGraphInterface_ParentNodeIds(swig_self(), (&node_id)->c_str());
  return vector_string{swig_cres, false};
}
inline Status CompiledGraphInterface::Visualize(std::string const& output_path) const {
  auto swig_cres = inworld_CompiledGraphInterface_Visualize(swig_self(), (&output_path)->c_str());
  return Status{swig_cres, true};
}
inline DataStore::DataStore() : DataStore{inworld_DataStore_new()} {}
inline bool DataStore::Add(std::string const& key, BaseData const& arg3) { return inworld_DataStore_Add(swig_self(), (&key)->c_str(), arg3.swig_self()); }
inline StatusOr_BaseData DataStore::Get(std::string const& key) const {
  auto swig_cres = inworld_DataStore_Get(swig_self(), (&key)->c_str());
  return StatusOr_BaseData{swig_cres, true};
}
inline BaseData DataStore::GetOrDefault(std::string const& key, BaseData const& arg3) const {
  auto swig_cres = inworld_DataStore_GetOrDefault(swig_self(), (&key)->c_str(), arg3.swig_self());
  return BaseData{swig_cres, true};
}
inline bool DataStore::Contains(std::string const& key) const { return inworld_DataStore_Contains(swig_self(), (&key)->c_str()); }
inline vector_string DataStore::GetKeys() const {
  auto swig_cres = inworld_DataStore_GetKeys(swig_self());
  return vector_string{swig_cres, true};
}
inline size_t DataStore::Size() const { return inworld_DataStore_Size(swig_self()); }
inline bool DataStore::Empty() const { return inworld_DataStore_Empty(swig_self()); }
inline bool DataStore::is_valid() const { return inworld_DataStore_is_valid(swig_self()); }
inline EdgeContext EdgeContext::Create(std::string const& execution_id, DataStore const& arg2, CancellationContext const& arg3) {
  auto swig_cres = inworld_EdgeContext_Create((&execution_id)->c_str(), arg2.swig_self(), arg3.swig_self());
  return EdgeContext{swig_cres, true};
}
inline std::string EdgeContext::GetExecutionId() const {
  auto swig_cres = inworld_EdgeContext_GetExecutionId(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline DataStore EdgeContext::GetDataStore() const {
  auto swig_cres = inworld_EdgeContext_GetDataStore(swig_self());
  return DataStore{swig_cres, true};
}
inline bool EdgeContext::IsCancelled() const { return inworld_EdgeContext_IsCancelled(swig_self()); }
inline CancellationContext EdgeContext::GetCancellationContext() const {
  auto swig_cres = inworld_EdgeContext_GetCancellationContext(swig_self());
  return CancellationContext{swig_cres, true};
}
inline bool EdgeContext::is_valid() const { return inworld_EdgeContext_is_valid(swig_self()); }
inline StatusOr_CompiledGraphInterfacePtr::StatusOr_CompiledGraphInterfacePtr() : StatusOr_CompiledGraphInterfacePtr{inworld_StatusOr_CompiledGraphInterfacePtr_new()} {}
inline StatusOr_CompiledGraphInterfacePtr::StatusOr_CompiledGraphInterfacePtr(CompiledGraphInterface * value) : StatusOr_CompiledGraphInterfacePtr{inworld_StatusOr_CompiledGraphInterfacePtr_new_rcpinworld_graphs_CompiledGraphInterface(value->swig_self())} {}
inline StatusOr_CompiledGraphInterfacePtr::StatusOr_CompiledGraphInterfacePtr(Status const & status) : StatusOr_CompiledGraphInterfacePtr{inworld_StatusOr_CompiledGraphInterfacePtr_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_CompiledGraphInterfacePtr::ok() const { return inworld_StatusOr_CompiledGraphInterfacePtr_ok(swig_self()); }
inline Status StatusOr_CompiledGraphInterfacePtr::status() const {
  auto swig_cres = inworld_StatusOr_CompiledGraphInterfacePtr_status(swig_self());
  return Status{swig_cres, false};
}
inline CompiledGraphInterface * StatusOr_CompiledGraphInterfacePtr::value() const {
  auto swig_cres = inworld_StatusOr_CompiledGraphInterfacePtr_value(swig_self());
  return swig_cres ? new CompiledGraphInterface(swig_cres, false) : nullptr;
}
inline StatusOr_CompiledGraphInterfacePtr::StatusOr_CompiledGraphInterfacePtr(StatusOr_CompiledGraphInterfacePtr const & other) : StatusOr_CompiledGraphInterfacePtr{inworld_StatusOr_CompiledGraphInterfacePtr_copy(other.swig_self())} {}
inline StatusOr_ConfigParserPtr::StatusOr_ConfigParserPtr() : StatusOr_ConfigParserPtr{inworld_StatusOr_ConfigParserPtr_new()} {}
inline StatusOr_ConfigParserPtr::StatusOr_ConfigParserPtr(ConfigParser * value) : StatusOr_ConfigParserPtr{inworld_StatusOr_ConfigParserPtr_new_rcpinworld_graphs_ConfigParser(value->swig_self())} {}
inline StatusOr_ConfigParserPtr::StatusOr_ConfigParserPtr(Status const & status) : StatusOr_ConfigParserPtr{inworld_StatusOr_ConfigParserPtr_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_ConfigParserPtr::ok() const { return inworld_StatusOr_ConfigParserPtr_ok(swig_self()); }
inline Status StatusOr_ConfigParserPtr::status() const {
  auto swig_cres = inworld_StatusOr_ConfigParserPtr_status(swig_self());
  return Status{swig_cres, false};
}
inline ConfigParser * StatusOr_ConfigParserPtr::value() const {
  auto swig_cres = inworld_StatusOr_ConfigParserPtr_value(swig_self());
  return swig_cres ? new ConfigParser(swig_cres, false) : nullptr;
}
inline StatusOr_ConfigParserPtr::StatusOr_ConfigParserPtr(StatusOr_ConfigParserPtr const & other) : StatusOr_ConfigParserPtr{inworld_StatusOr_ConfigParserPtr_copy(other.swig_self())} {}
inline StatusOr_ConfigParserPtr ConfigParser::inworld_inworld_graphs_ConfigParser_CreateConfigParser__SWIG() {
  auto swig_cres = inworld_ConfigParser_CreateConfigParser();
  return StatusOr_ConfigParserPtr{swig_cres, true};
}
inline StatusOr_ConfigParserPtr ConfigParser::inworld_inworld_graphs_ConfigParser_CreateConfigParserWithDefaults__SWIG(HashMap_StringToString const & default_substitutions) {
  auto swig_cres = inworld_ConfigParser_CreateConfigParserWithDefaults(default_substitutions.swig_self());
  return StatusOr_ConfigParserPtr{swig_cres, true};
}
inline StatusOr_CompiledGraphInterfacePtr ConfigParser::ParseGraphFromJsonString(const char * config_string) {
  auto swig_cres = inworld_ConfigParser_ParseGraphFromJsonString(swig_self(), config_string);
  return StatusOr_CompiledGraphInterfacePtr{swig_cres, true};
}
inline StatusOr_CompiledGraphInterfacePtr ConfigParser::ParseGraphFromJsonStringWithSubstitutions(const char * config_string, HashMap_StringToString const & arg3) {
  auto swig_cres = inworld_ConfigParser_ParseGraphFromJsonStringWithSubstitutions(swig_self(), config_string, arg3.swig_self());
  return StatusOr_CompiledGraphInterfacePtr{swig_cres, true};
}
inline Graph::Graph(std::string const& id) : Graph{inworld_Graph_new((&id)->c_str())} {}
inline void Graph::AddNode(Node const& node) { inworld_Graph_AddNode(swig_self(), node.swig_self()); }
inline void Graph::SetAsStart(Node const& node) { inworld_Graph_SetAsStart(swig_self(), node.swig_self()); }
inline void Graph::SetAsEnd(Node const& node) { inworld_Graph_SetAsEnd(swig_self(), node.swig_self()); }
inline StatusOr_CompiledGraphInterfacePtr Graph::CompileAndReturnRaw() {
  auto swig_cres = inworld_Graph_CompileAndReturnRaw(swig_self());
  return StatusOr_CompiledGraphInterfacePtr{swig_cres, true};
}
inline EdgeWrapper Graph::CreateEdge(Node const& from_node, Node const& arg3) {
  auto swig_cres = inworld_Graph_CreateEdge(swig_self(), from_node.swig_self(), arg3.swig_self());
  return EdgeWrapper{swig_cres, true};
}
inline StatusOr_CreationContext Graph::GetCreationContextHelper() {
  auto swig_cres = inworld_Graph_GetCreationContextHelper(swig_self());
  return StatusOr_CreationContext{swig_cres, true};
}
inline Status Graph::AddComponent_LLMInterface(std::string const& id, LLMInterface const& arg3) {
  auto swig_cres = inworld_Graph_AddComponent_LLMInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status Graph::AddComponent_STTInterface(std::string const& id, STTInterface const& arg3) {
  auto swig_cres = inworld_Graph_AddComponent_STTInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status Graph::AddComponent_StreamingSTTInterface(std::string const& id, StreamingSTTInterface const& arg3) {
  auto swig_cres = inworld_Graph_AddComponent_StreamingSTTInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status Graph::AddComponent_TTSInterface(std::string const& id, TTSInterface const& arg3) {
  auto swig_cres = inworld_Graph_AddComponent_TTSInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status Graph::AddComponent_TextEmbedderInterface(std::string const& id, TextEmbedderInterface const& arg3) {
  auto swig_cres = inworld_Graph_AddComponent_TextEmbedderInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status Graph::AddComponent_KnowledgeInterface(std::string const& id, KnowledgeInterface const& arg3) {
  auto swig_cres = inworld_Graph_AddComponent_KnowledgeInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status Graph::AddComponent_MCPClientInterface(std::string const& id, MCPClientInterface const& arg3) {
  auto swig_cres = inworld_Graph_AddComponent_MCPClientInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline EdgeConditionExecutor::EdgeConditionExecutor(void * opaque_callback, void * arg2) : EdgeConditionExecutor{inworld_EdgeConditionExecutor_new_pv_pv(opaque_callback, arg2)} {}
inline EdgeConditionExecutor::EdgeConditionExecutor(EdgeConditionExecutor const & other) : EdgeConditionExecutor{inworld_EdgeConditionExecutor_copy(other.swig_self())} {}
inline EdgeContext EdgeConditionExecutor::GetLastEdgeContext() {
  auto swig_cres = inworld_EdgeConditionExecutor_GetLastEdgeContext();
  return EdgeContext{swig_cres, true};
}
inline BaseData EdgeConditionExecutor::GetLastInput() {
  auto swig_cres = inworld_EdgeConditionExecutor_GetLastInput();
  return BaseData{swig_cres, true};
}
inline void EdgeConditionExecutor::SetNextOutput(bool output) { inworld_EdgeConditionExecutor_SetNextOutput(output); }
inline void EdgeConditionExecutor::SetNextError(std::string const& error) { inworld_EdgeConditionExecutor_SetNextError((&error)->c_str()); }
inline EdgeConditionThreadedExecutor::EdgeConditionThreadedExecutor(void * context, void * arg2) : EdgeConditionThreadedExecutor{inworld_EdgeConditionThreadedExecutor_new_pv_pv(context, arg2)} {}
inline BaseData EdgeConditionThreadedExecutor::GetInput(int execution_id) {
  auto swig_cres = inworld_EdgeConditionThreadedExecutor_GetInput(execution_id);
  return BaseData{swig_cres, true};
}
inline EdgeContext EdgeConditionThreadedExecutor::GetEdgeContext(int execution_id) {
  auto swig_cres = inworld_EdgeConditionThreadedExecutor_GetEdgeContext(execution_id);
  return EdgeContext{swig_cres, true};
}
inline void EdgeConditionThreadedExecutor::SetOutput(int execution_id, bool arg2) { inworld_EdgeConditionThreadedExecutor_SetOutput(execution_id, arg2); }
inline void EdgeConditionThreadedExecutor::SetError(int execution_id, std::string const& arg2) { inworld_EdgeConditionThreadedExecutor_SetError(execution_id, (&arg2)->c_str()); }
inline EdgeConditionThreadedExecutor::EdgeConditionThreadedExecutor(EdgeConditionThreadedExecutor const & other) : EdgeConditionThreadedExecutor{inworld_EdgeConditionThreadedExecutor_copy(other.swig_self())} {}
inline EdgeWrapper::EdgeWrapper(EdgeWrapper const & other) : EdgeWrapper{inworld_EdgeWrapper_copy(other.swig_self())} {}
inline void EdgeWrapper::SetCondition(EdgeConditionExecutor const & condition) { inworld_EdgeWrapper_SetCondition_rcinworld_swig_helpers_EdgeConditionExecutor(swig_self(), condition.swig_self()); }
inline void EdgeWrapper::SetCondition(EdgeConditionThreadedExecutor const & condition) { inworld_EdgeWrapper_SetCondition_rcinworld_swig_helpers_EdgeConditionThreadedExecutor(swig_self(), condition.swig_self()); }
inline void EdgeWrapper::SetToOptional() { inworld_EdgeWrapper_SetToOptional(swig_self()); }
inline void EdgeWrapper::SetToLoop() { inworld_EdgeWrapper_SetToLoop(swig_self()); }
inline void EdgeWrapper::Build() { inworld_EdgeWrapper_Build(swig_self()); }
inline StatusOr_Tools MCPClientInterface::ListTools() const {
  auto swig_cres = inworld_MCPClientInterface_ListTools(swig_self());
  return StatusOr_Tools{swig_cres, true};
}
inline bool MCPClientInterface::is_valid() const { return inworld_MCPClientInterface_is_valid(swig_self()); }
inline StatusOr_string MCPClientInterface::Call(ToolCall const & tool_call) const {
  auto swig_cres = inworld_MCPClientInterface_Call(swig_self(), tool_call.swig_self());
  return StatusOr_string{swig_cres, true};
}
inline vector_Node::vector_Node() : vector_Node{inworld_vector_Node_new()} {}
inline vector_Node::vector_Node(vector_Node const & other) : vector_Node{inworld_vector_Node_copy(other.swig_self())} {}
inline size_t vector_Node::size() const { return inworld_vector_Node_size(swig_self()); }
inline size_t vector_Node::capacity() const { return inworld_vector_Node_capacity(swig_self()); }
inline void vector_Node::reserve(size_t n) { inworld_vector_Node_reserve(swig_self(), n); }
inline bool vector_Node::empty() const { return inworld_vector_Node_empty(swig_self()); }
inline void vector_Node::clear() { inworld_vector_Node_clear(swig_self()); }
inline void vector_Node::push_back(Node const& x) { inworld_vector_Node_push_back(swig_self(), x.swig_self()); }
inline Node vector_Node::get(int i) {
  auto swig_cres = inworld_vector_Node_get(swig_self(), i);
  return Node{swig_cres, true};
}
inline void vector_Node::set(int i, Node const& arg3) { inworld_vector_Node_set(swig_self(), i, arg3.swig_self()); }
inline LinearGraph::LinearGraph(std::string const& id, vector_Node const & arg2) : LinearGraph{inworld_LinearGraph_new((&id)->c_str(), arg2.swig_self())} {}
inline void LinearGraph::AddNode(Node const& node) { inworld_LinearGraph_AddNode(swig_self(), node.swig_self()); }
inline StatusOr_CreationContext LinearGraph::GetCreationContextHelper() const {
  auto swig_cres = inworld_LinearGraph_GetCreationContextHelper(swig_self());
  return StatusOr_CreationContext{swig_cres, true};
}
inline Status LinearGraph::AddComponent_LLMInterface(std::string const& id, LLMInterface const& arg3) {
  auto swig_cres = inworld_LinearGraph_AddComponent_LLMInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status LinearGraph::AddComponent_STTInterface(std::string const& id, STTInterface const& arg3) {
  auto swig_cres = inworld_LinearGraph_AddComponent_STTInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status LinearGraph::AddComponent_StreamingSTTInterface(std::string const& id, StreamingSTTInterface const& arg3) {
  auto swig_cres = inworld_LinearGraph_AddComponent_StreamingSTTInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status LinearGraph::AddComponent_TTSInterface(std::string const& id, TTSInterface const& arg3) {
  auto swig_cres = inworld_LinearGraph_AddComponent_TTSInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status LinearGraph::AddComponent_TextEmbedderInterface(std::string const& id, TextEmbedderInterface const& arg3) {
  auto swig_cres = inworld_LinearGraph_AddComponent_TextEmbedderInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status LinearGraph::AddComponent_KnowledgeInterface(std::string const& id, KnowledgeInterface const& arg3) {
  auto swig_cres = inworld_LinearGraph_AddComponent_KnowledgeInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline Status LinearGraph::AddComponent_MCPClientInterface(std::string const& id, MCPClientInterface const& arg3) {
  auto swig_cres = inworld_LinearGraph_AddComponent_MCPClientInterface(swig_self(), (&id)->c_str(), arg3.swig_self());
  return Status{swig_cres, true};
}
inline StatusOr_TTSOutput::StatusOr_TTSOutput() : StatusOr_TTSOutput{inworld_StatusOr_TTSOutput_new()} {}
inline StatusOr_TTSOutput::StatusOr_TTSOutput(TTSOutput const & value) : StatusOr_TTSOutput{inworld_StatusOr_TTSOutput_new_rcinworld_graphs_TTSOutput(value.swig_self())} {}
inline StatusOr_TTSOutput::StatusOr_TTSOutput(Status const & status) : StatusOr_TTSOutput{inworld_StatusOr_TTSOutput_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_TTSOutput::ok() const { return inworld_StatusOr_TTSOutput_ok(swig_self()); }
inline Status StatusOr_TTSOutput::status() const {
  auto swig_cres = inworld_StatusOr_TTSOutput_status(swig_self());
  return Status{swig_cres, false};
}
inline TTSOutput StatusOr_TTSOutput::value() const {
  auto swig_cres = inworld_StatusOr_TTSOutput_value(swig_self());
  return TTSOutput{swig_cres, true};
}
inline StatusOr_TTSOutput::StatusOr_TTSOutput(StatusOr_TTSOutput const & other) : StatusOr_TTSOutput{inworld_StatusOr_TTSOutput_copy(other.swig_self())} {}
inline DataStream_TTSOutput::DataStream_TTSOutput(InputStream_TTSOutput const& stream, ProcessContext const & arg2) : DataStream_TTSOutput{inworld_DataStream_TTSOutput_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg__rcinworld_graphs_ProcessContext(stream.swig_self(), arg2.swig_self())} {}
inline DataStream_TTSOutput::DataStream_TTSOutput(InputStream_TTSOutput const& stream) : DataStream_TTSOutput{inworld_DataStream_TTSOutput_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_graphs_TTSOutput_Sg__Sg_(stream.swig_self())} {}
inline DataStream_TTSOutput::DataStream_TTSOutput(DataStream_TTSOutput const & other) : DataStream_TTSOutput{inworld_DataStream_TTSOutput_copy(other.swig_self())} {}
inline InputStream_TTSOutput DataStream_TTSOutput::stream() const {
  auto swig_cres = inworld_DataStream_TTSOutput_stream(swig_self());
  return InputStream_TTSOutput{swig_cres, true};
}
inline CancellationContext DataStream_TTSOutput::cancellation_context() const {
  auto swig_cres = inworld_DataStream_TTSOutput_cancellation_context(swig_self());
  return CancellationContext{swig_cres, true};
}
inline bool DataStream_TTSOutput::is_valid() const { return inworld_DataStream_TTSOutput_is_valid(swig_self()); }
inline DataStream_String::DataStream_String(InputStream_string const& stream, ProcessContext const & arg2) : DataStream_String{inworld_DataStream_String_new_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg__rcinworld_graphs_ProcessContext(stream.swig_self(), arg2.swig_self())} {}
inline DataStream_String::DataStream_String(InputStream_string const& stream) : DataStream_String{inworld_DataStream_String_new_std_shared_ptr_Sl_inworld_InputStream_Sl_std_string_Sg__Sg_(stream.swig_self())} {}
inline DataStream_String::DataStream_String(DataStream_String const & other) : DataStream_String{inworld_DataStream_String_copy(other.swig_self())} {}
inline InputStream_string DataStream_String::stream() const {
  auto swig_cres = inworld_DataStream_String_stream(swig_self());
  return InputStream_string{swig_cres, true};
}
inline CancellationContext DataStream_String::cancellation_context() const {
  auto swig_cres = inworld_DataStream_String_cancellation_context(swig_self());
  return CancellationContext{swig_cres, true};
}
inline bool DataStream_String::is_valid() const { return inworld_DataStream_String_is_valid(swig_self()); }
inline DataStream_Content::DataStream_Content(InputStream_Content const& stream, ProcessContext const & arg2) : DataStream_Content{inworld_DataStream_Content_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg__rcinworld_graphs_ProcessContext(stream.swig_self(), arg2.swig_self())} {}
inline DataStream_Content::DataStream_Content(InputStream_Content const& stream) : DataStream_Content{inworld_DataStream_Content_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_Content_Sg__Sg_(stream.swig_self())} {}
inline DataStream_Content::DataStream_Content(DataStream_Content const & other) : DataStream_Content{inworld_DataStream_Content_copy(other.swig_self())} {}
inline InputStream_Content DataStream_Content::stream() const {
  auto swig_cres = inworld_DataStream_Content_stream(swig_self());
  return InputStream_Content{swig_cres, true};
}
inline CancellationContext DataStream_Content::cancellation_context() const {
  auto swig_cres = inworld_DataStream_Content_cancellation_context(swig_self());
  return CancellationContext{swig_cres, true};
}
inline bool DataStream_Content::is_valid() const { return inworld_DataStream_Content_is_valid(swig_self()); }
inline DataStream_AudioChunk::DataStream_AudioChunk(InputStream_AudioChunk const& stream, ProcessContext const & arg2) : DataStream_AudioChunk{inworld_DataStream_AudioChunk_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg__rcinworld_graphs_ProcessContext(stream.swig_self(), arg2.swig_self())} {}
inline DataStream_AudioChunk::DataStream_AudioChunk(InputStream_AudioChunk const& stream) : DataStream_AudioChunk{inworld_DataStream_AudioChunk_new_std_shared_ptr_Sl_inworld_InputStream_Sl_inworld_AudioChunk_Sg__Sg_(stream.swig_self())} {}
inline DataStream_AudioChunk::DataStream_AudioChunk(DataStream_AudioChunk const & other) : DataStream_AudioChunk{inworld_DataStream_AudioChunk_copy(other.swig_self())} {}
inline InputStream_AudioChunk DataStream_AudioChunk::stream() const {
  auto swig_cres = inworld_DataStream_AudioChunk_stream(swig_self());
  return InputStream_AudioChunk{swig_cres, true};
}
inline CancellationContext DataStream_AudioChunk::cancellation_context() const {
  auto swig_cres = inworld_DataStream_AudioChunk_cancellation_context(swig_self());
  return CancellationContext{swig_cres, true};
}
inline bool DataStream_AudioChunk::is_valid() const { return inworld_DataStream_AudioChunk_is_valid(swig_self()); }
inline DataStream_BaseData::DataStream_BaseData(InputStream_BaseData const& stream, ProcessContext const & arg2) : DataStream_BaseData{inworld_DataStream_BaseData_new_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg__rcinworld_graphs_ProcessContext(stream.swig_self(), arg2.swig_self())} {}
inline DataStream_BaseData::DataStream_BaseData(InputStream_BaseData const& stream) : DataStream_BaseData{inworld_DataStream_BaseData_new_std_shared_ptr_Sl_inworld_InputStream_Sl_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg__Sg_(stream.swig_self())} {}
inline DataStream_BaseData::DataStream_BaseData(DataStream_BaseData const & other) : DataStream_BaseData{inworld_DataStream_BaseData_copy(other.swig_self())} {}
inline InputStream_BaseData DataStream_BaseData::stream() const {
  auto swig_cres = inworld_DataStream_BaseData_stream(swig_self());
  return InputStream_BaseData{swig_cres, true};
}
inline CancellationContext DataStream_BaseData::cancellation_context() const {
  auto swig_cres = inworld_DataStream_BaseData_cancellation_context(swig_self());
  return CancellationContext{swig_cres, true};
}
inline bool DataStream_BaseData::is_valid() const { return inworld_DataStream_BaseData_is_valid(swig_self()); }
inline DataStream_TTSOutput BaseDataAs_DataStream_TTSOutput(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_DataStream_TTSOutput(base_data.swig_self());
  return DataStream_TTSOutput{swig_cres, true};
}
inline DataStream_String BaseDataAs_DataStream_String(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_DataStream_String(base_data.swig_self());
  return DataStream_String{swig_cres, true};
}
inline DataStream_Content BaseDataAs_DataStream_Content(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_DataStream_Content(base_data.swig_self());
  return DataStream_Content{swig_cres, true};
}
inline DataStream_AudioChunk BaseDataAs_DataStream_AudioChunk(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_DataStream_AudioChunk(base_data.swig_self());
  return DataStream_AudioChunk{swig_cres, true};
}
inline DataStream_BaseData BaseDataAs_DataStream_BaseData(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_DataStream_BaseData(base_data.swig_self());
  return DataStream_BaseData{swig_cres, true};
}
inline EventHistory::EventHistory() : EventHistory{inworld_EventHistory_new()} {}
inline EventHistory::EventHistory(vector_Event const& events) : EventHistory{inworld_EventHistory_new_std_vector_Sl_inworld_Event_Sg_(events.swig_self())} {}
inline vector_Event EventHistory::events() const {
  auto swig_cres = inworld_EventHistory_events(swig_self());
  return vector_Event{swig_cres, false};
}
inline bool EventHistory::is_valid() const { return inworld_EventHistory_is_valid(swig_self()); }
inline EventHistory::EventHistory(EventHistory const & other) : EventHistory{inworld_EventHistory_copy(other.swig_self())} {}
inline EventHistory BaseDataAs_EventHistory(BaseData const& base_data) {
  auto swig_cres = inworld_BaseDataAs_EventHistory(base_data.swig_self());
  return EventHistory{swig_cres, true};
}
inline StatusOr_CustomNodeWrapper::StatusOr_CustomNodeWrapper() : StatusOr_CustomNodeWrapper{inworld_StatusOr_CustomNodeWrapper_new()} {}
inline StatusOr_CustomNodeWrapper::StatusOr_CustomNodeWrapper(CustomNodeWrapper const& value) : StatusOr_CustomNodeWrapper{inworld_StatusOr_CustomNodeWrapper_new_rcstd_shared_ptr_Sl_inworld_swig_helpers_CustomNodeWrapper_Sg_(value.swig_self())} {}
inline StatusOr_CustomNodeWrapper::StatusOr_CustomNodeWrapper(Status const & status) : StatusOr_CustomNodeWrapper{inworld_StatusOr_CustomNodeWrapper_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_CustomNodeWrapper::ok() const { return inworld_StatusOr_CustomNodeWrapper_ok(swig_self()); }
inline Status StatusOr_CustomNodeWrapper::status() const {
  auto swig_cres = inworld_StatusOr_CustomNodeWrapper_status(swig_self());
  return Status{swig_cres, false};
}
inline CustomNodeWrapper StatusOr_CustomNodeWrapper::value() const {
  auto swig_cres = inworld_StatusOr_CustomNodeWrapper_value(swig_self());
  return CustomNodeWrapper{swig_cres, true};
}
inline StatusOr_CustomNodeWrapper::StatusOr_CustomNodeWrapper(StatusOr_CustomNodeWrapper const & other) : StatusOr_CustomNodeWrapper{inworld_StatusOr_CustomNodeWrapper_copy(other.swig_self())} {}
inline CustomNodeThreadedCreateExecutor::CustomNodeThreadedCreateExecutor(void * context, void * arg2) : CustomNodeThreadedCreateExecutor{inworld_CustomNodeThreadedCreateExecutor_new_pv_pv(context, arg2)} {}
inline std::string CustomNodeThreadedCreateExecutor::GetInputId(int execution_id) {
  auto swig_cres = inworld_CustomNodeThreadedCreateExecutor_GetInputId(execution_id);
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline CreationContext CustomNodeThreadedCreateExecutor::GetInputCreationContext(int execution_id) {
  auto swig_cres = inworld_CustomNodeThreadedCreateExecutor_GetInputCreationContext(execution_id);
  return CreationContext{swig_cres, true};
}
inline CustomExecutionConfigWrapper CustomNodeThreadedCreateExecutor::GetInputExecutionConfig(int execution_id) {
  auto swig_cres = inworld_CustomNodeThreadedCreateExecutor_GetInputExecutionConfig(execution_id);
  return CustomExecutionConfigWrapper{swig_cres, true};
}
inline vector_CustomConfigWrapper CustomNodeThreadedCreateExecutor::GetInputConfigs(int execution_id) {
  auto swig_cres = inworld_CustomNodeThreadedCreateExecutor_GetInputConfigs(execution_id);
  return vector_CustomConfigWrapper{swig_cres, true};
}
inline void CustomNodeThreadedCreateExecutor::SetOutput(int execution_id, StatusOr_CustomNodeWrapper const & arg2) { inworld_CustomNodeThreadedCreateExecutor_SetOutput(execution_id, arg2.swig_self()); }
inline CustomNodeThreadedCreateExecutor::CustomNodeThreadedCreateExecutor(CustomNodeThreadedCreateExecutor const & other) : CustomNodeThreadedCreateExecutor{inworld_CustomNodeThreadedCreateExecutor_copy(other.swig_self())} {}
inline HashMap_StringToString::HashMap_StringToString() : HashMap_StringToString{inworld_HashMap_StringToString_new()} {}
inline size_t HashMap_StringToString::size() const { return inworld_HashMap_StringToString_size(swig_self()); }
inline bool HashMap_StringToString::empty() const { return inworld_HashMap_StringToString_empty(swig_self()); }
inline void HashMap_StringToString::clear() { inworld_HashMap_StringToString_clear(swig_self()); }
inline char * HashMap_StringToString::__getitem__(std::string const& key) { return inworld_HashMap_StringToString___getitem__(swig_self(), (&key)->c_str()); }
inline void HashMap_StringToString::__setitem__(std::string const& key, std::string const& arg3) { inworld_HashMap_StringToString___setitem__(swig_self(), (&key)->c_str(), (&arg3)->c_str()); }
inline bool HashMap_StringToString::__contains__(std::string const& key) { return inworld_HashMap_StringToString___contains__(swig_self(), (&key)->c_str()); }
inline HashMap_StringToString::HashMap_StringToString(HashMap_StringToString const & other) : HashMap_StringToString{inworld_HashMap_StringToString_copy(other.swig_self())} {}
inline BTreeMap_StringToString::BTreeMap_StringToString() : BTreeMap_StringToString{inworld_BTreeMap_StringToString_new()} {}
inline size_t BTreeMap_StringToString::size() const { return inworld_BTreeMap_StringToString_size(swig_self()); }
inline bool BTreeMap_StringToString::empty() const { return inworld_BTreeMap_StringToString_empty(swig_self()); }
inline void BTreeMap_StringToString::clear() { inworld_BTreeMap_StringToString_clear(swig_self()); }
inline char * BTreeMap_StringToString::__getitem__(std::string const& key) { return inworld_BTreeMap_StringToString___getitem__(swig_self(), (&key)->c_str()); }
inline void BTreeMap_StringToString::__setitem__(std::string const& key, std::string const& arg3) { inworld_BTreeMap_StringToString___setitem__(swig_self(), (&key)->c_str(), (&arg3)->c_str()); }
inline bool BTreeMap_StringToString::__contains__(std::string const& key) { return inworld_BTreeMap_StringToString___contains__(swig_self(), (&key)->c_str()); }
inline BTreeMap_StringToString::BTreeMap_StringToString(BTreeMap_StringToString const & other) : BTreeMap_StringToString{inworld_BTreeMap_StringToString_copy(other.swig_self())} {}
inline HashMap_StringToBaseData::HashMap_StringToBaseData() : HashMap_StringToBaseData{inworld_HashMap_StringToBaseData_new()} {}
inline size_t HashMap_StringToBaseData::size() const { return inworld_HashMap_StringToBaseData_size(swig_self()); }
inline bool HashMap_StringToBaseData::empty() const { return inworld_HashMap_StringToBaseData_empty(swig_self()); }
inline void HashMap_StringToBaseData::clear() { inworld_HashMap_StringToBaseData_clear(swig_self()); }
inline BaseData HashMap_StringToBaseData::__getitem__(std::string const& key) {
  auto swig_cres = inworld_HashMap_StringToBaseData___getitem__(swig_self(), (&key)->c_str());
  return BaseData{swig_cres, false};
}
inline void HashMap_StringToBaseData::__setitem__(std::string const& key, BaseData const& arg3) { inworld_HashMap_StringToBaseData___setitem__(swig_self(), (&key)->c_str(), arg3.swig_self()); }
inline bool HashMap_StringToBaseData::__contains__(std::string const& key) { return inworld_HashMap_StringToBaseData___contains__(swig_self(), (&key)->c_str()); }
inline HashMap_StringToBaseData::HashMap_StringToBaseData(HashMap_StringToBaseData const & other) : HashMap_StringToBaseData{inworld_HashMap_StringToBaseData_copy(other.swig_self())} {}
inline OptionalHashMapStringToBaseData::OptionalHashMapStringToBaseData() : OptionalHashMapStringToBaseData{inworld_OptionalHashMapStringToBaseData_new()} {}
inline OptionalHashMapStringToBaseData::OptionalHashMapStringToBaseData(HashMap_StringToBaseData const & value) : OptionalHashMapStringToBaseData{inworld_OptionalHashMapStringToBaseData_new_rcabsl_flat_hash_map_Sl_std_string_Sc_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__Sg_(value.swig_self())} {}
inline OptionalHashMapStringToBaseData::OptionalHashMapStringToBaseData(OptionalHashMapStringToBaseData const & other) : OptionalHashMapStringToBaseData{inworld_OptionalHashMapStringToBaseData_copy(other.swig_self())} {}
inline bool OptionalHashMapStringToBaseData::has_value() const { return inworld_OptionalHashMapStringToBaseData_has_value(swig_self()); }
inline HashMap_StringToBaseData OptionalHashMapStringToBaseData::value() {
  auto swig_cres = inworld_OptionalHashMapStringToBaseData_value(swig_self());
  return HashMap_StringToBaseData{swig_cres, false};
}
inline HashMap_StringToBaseData OptionalHashMapStringToBaseData::value() const {
  auto swig_cres = inworld_OptionalHashMapStringToBaseData_valueConst(swig_self());
  return HashMap_StringToBaseData{swig_cres, false};
}
inline HashMap_StringToBaseData OptionalHashMapStringToBaseData::value_or(HashMap_StringToBaseData const & default_value) const {
  auto swig_cres = inworld_OptionalHashMapStringToBaseData_value_or(swig_self(), default_value.swig_self());
  return HashMap_StringToBaseData{swig_cres, true};
}
inline void OptionalHashMapStringToBaseData::reset() { inworld_OptionalHashMapStringToBaseData_reset(swig_self()); }
inline HashMap_StringToBaseData OptionalHashMapStringToBaseData::operator *() {
  auto swig_cres = inworld_OptionalHashMapStringToBaseData_get(swig_self());
  return HashMap_StringToBaseData{swig_cres, false};
}
inline HashMap_StringToBaseData OptionalHashMapStringToBaseData::operator *() const {
  auto swig_cres = inworld_OptionalHashMapStringToBaseData_getConst(swig_self());
  return HashMap_StringToBaseData{swig_cres, false};
}
inline HashMap_StringToBaseData OptionalHashMapStringToBaseData::get_value() {
  auto swig_cres = inworld_OptionalHashMapStringToBaseData_get_value(swig_self());
  return HashMap_StringToBaseData{swig_cres, false};
}
inline void OptionalHashMapStringToBaseData::set_value(HashMap_StringToBaseData & t) { inworld_OptionalHashMapStringToBaseData_set_value(swig_self(), t.swig_self()); }
inline StatusOr_ResultItem::StatusOr_ResultItem() : StatusOr_ResultItem{inworld_StatusOr_ResultItem_new()} {}
inline StatusOr_ResultItem::StatusOr_ResultItem(ResultItem const & value) : StatusOr_ResultItem{inworld_StatusOr_ResultItem_new_rcinworld_graphs_ResultItem(value.swig_self())} {}
inline StatusOr_ResultItem::StatusOr_ResultItem(Status const & status) : StatusOr_ResultItem{inworld_StatusOr_ResultItem_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_ResultItem::ok() const { return inworld_StatusOr_ResultItem_ok(swig_self()); }
inline Status StatusOr_ResultItem::status() const {
  auto swig_cres = inworld_StatusOr_ResultItem_status(swig_self());
  return Status{swig_cres, false};
}
inline ResultItem StatusOr_ResultItem::value() const {
  auto swig_cres = inworld_StatusOr_ResultItem_value(swig_self());
  return ResultItem{swig_cres, true};
}
inline StatusOr_ResultItem::StatusOr_ResultItem(StatusOr_ResultItem const & other) : StatusOr_ResultItem{inworld_StatusOr_ResultItem_copy(other.swig_self())} {}
inline bool InputStream_ResultItem::HasNext() { return inworld_InputStream_ResultItem_HasNext(swig_self()); }
inline StatusOr_ResultItem InputStream_ResultItem::Read() {
  auto swig_cres = inworld_InputStream_ResultItem_Read(swig_self());
  return StatusOr_ResultItem{swig_cres, true};
}
inline void InputStream_ResultItem::Cancel() { inworld_InputStream_ResultItem_Cancel(swig_self()); }
inline bool InputStream_ResultItem::is_valid() const { return inworld_InputStream_ResultItem_is_valid(swig_self()); }
inline ResultItem::ResultItem(BaseData const& value, optional_string const& arg2) : ResultItem{inworld_ResultItem_new_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__std_optional_Sl_std_string_Sg_(value.swig_self(), arg2.swig_self())} {}
inline ResultItem::ResultItem(BaseData const& value) : ResultItem{inworld_ResultItem_new_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg_(value.swig_self())} {}
inline void ResultItem::value(BaseData const& value) { inworld_ResultItem_value_set(swig_self(), value.swig_self()); }
inline BaseData ResultItem::value() const {
  auto swig_cres = inworld_ResultItem_value_get(swig_self());
  return BaseData{swig_cres, true};
}
inline void ResultItem::node_id(optional_string * node_id) { inworld_ResultItem_node_id_set(swig_self(), node_id->swig_self()); }
inline optional_string * ResultItem::node_id() const {
  auto swig_cres = inworld_ResultItem_node_id_get(swig_self());
  return swig_cres ? new optional_string(swig_cres, false) : nullptr;
}
inline BaseData ResultItem::safe_value() const {
  auto swig_cres = inworld_ResultItem_safe_value(swig_self());
  return BaseData{swig_cres, true};
}
inline ResultItem::ResultItem(ResultItem const & other) : ResultItem{inworld_ResultItem_copy(other.swig_self())} {}
inline ExecutionResult ExecutionResult::CreateEmpty(std::string const& variant, std::string const& arg2) {
  auto swig_cres = inworld_ExecutionResult_CreateEmpty_rcstd_string_rcstd_string((&variant)->c_str(), (&arg2)->c_str());
  return ExecutionResult{swig_cres, true};
}
inline ExecutionResult ExecutionResult::CreateEmpty(std::string const& variant) {
  auto swig_cres = inworld_ExecutionResult_CreateEmpty_rcstd_string((&variant)->c_str());
  return ExecutionResult{swig_cres, true};
}
inline ExecutionResult ExecutionResult::CreateEmpty() {
  auto swig_cres = inworld_ExecutionResult_CreateEmpty();
  return ExecutionResult{swig_cres, true};
}
inline ExecutionResult ExecutionResult::CreateWithError(Status const & error_status, std::string const& arg2, std::string const& arg3) {
  auto swig_cres = inworld_ExecutionResult_CreateWithError(error_status.swig_self(), (&arg2)->c_str(), (&arg3)->c_str());
  return ExecutionResult{swig_cres, true};
}
inline void ExecutionResult::Cancel() { inworld_ExecutionResult_Cancel(swig_self()); }
inline InputStream_ResultItem ExecutionResult::GetResultStream() const {
  auto swig_cres = inworld_ExecutionResult_GetResultStream(swig_self());
  return InputStream_ResultItem{swig_cres, true};
}
inline std::string ExecutionResult::GetVariant() const {
  auto swig_cres = inworld_ExecutionResult_GetVariant(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline std::string ExecutionResult::GetExecutionId() const {
  auto swig_cres = inworld_ExecutionResult_GetExecutionId(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void UserContext::attributes(BTreeMap_StringToString * attributes) { inworld_UserContext_attributes_set(swig_self(), attributes->swig_self()); }
inline BTreeMap_StringToString * UserContext::attributes() const {
  auto swig_cres = inworld_UserContext_attributes_get(swig_self());
  return swig_cres ? new BTreeMap_StringToString(swig_cres, false) : nullptr;
}
inline void UserContext::targeting_key(std::string const& targeting_key) { inworld_UserContext_targeting_key_set(swig_self(), (&targeting_key)->c_str()); }
inline std::string UserContext::targeting_key() const {
  auto swig_cres = inworld_UserContext_targeting_key_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline UserContext::UserContext() : UserContext{inworld_UserContext_new()} {}
inline UserContext::UserContext(UserContext const & other) : UserContext{inworld_UserContext_copy(other.swig_self())} {}
inline void ExecutionContext::execution_id(optional_string * execution_id) { inworld_ExecutionContext_execution_id_set(swig_self(), execution_id->swig_self()); }
inline optional_string * ExecutionContext::execution_id() const {
  auto swig_cres = inworld_ExecutionContext_execution_id_get(swig_self());
  return swig_cres ? new optional_string(swig_cres, false) : nullptr;
}
inline void ExecutionContext::user_context(optional_UserContext * user_context) { inworld_ExecutionContext_user_context_set(swig_self(), user_context->swig_self()); }
inline optional_UserContext * ExecutionContext::user_context() const {
  auto swig_cres = inworld_ExecutionContext_user_context_get(swig_self());
  return swig_cres ? new optional_UserContext(swig_cres, false) : nullptr;
}
inline void ExecutionContext::data_to_store(OptionalHashMapStringToBaseData * data_to_store) { inworld_ExecutionContext_data_to_store_set(swig_self(), data_to_store->swig_self()); }
inline OptionalHashMapStringToBaseData * ExecutionContext::data_to_store() const {
  auto swig_cres = inworld_ExecutionContext_data_to_store_get(swig_self());
  return swig_cres ? new OptionalHashMapStringToBaseData(swig_cres, false) : nullptr;
}
inline ExecutionContext ExecutionContext::Empty() {
  auto swig_cres = inworld_ExecutionContext_Empty();
  return ExecutionContext{swig_cres, false};
}
inline ExecutionContext::ExecutionContext() : ExecutionContext{inworld_ExecutionContext_new()} {}
inline ExecutionContext::ExecutionContext(ExecutionContext const & other) : ExecutionContext{inworld_ExecutionContext_copy(other.swig_self())} {}
inline Status ExecutorInterface::Start() {
  auto swig_cres = inworld_ExecutorInterface_Start(swig_self());
  return Status{swig_cres, true};
}
inline ExecutionResult ExecutorInterface::Execute(BaseData const& input, ExecutionContext const & arg3) {
  auto swig_cres = inworld_ExecutorInterface_Execute_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg__rcinworld_graphs_ExecutionContext(swig_self(), input.swig_self(), arg3.swig_self());
  return ExecutionResult{swig_cres, true};
}
inline ExecutionResult ExecutorInterface::Execute(BaseData const& input) {
  auto swig_cres = inworld_ExecutorInterface_Execute_std_shared_ptr_Sl_inworld_graphs_BaseData_Sg_(swig_self(), input.swig_self());
  return ExecutionResult{swig_cres, true};
}
inline Status ExecutorInterface::Stop() {
  auto swig_cres = inworld_ExecutorInterface_Stop(swig_self());
  return Status{swig_cres, true};
}
inline StatusOr_ExecutorInterfacePtr::StatusOr_ExecutorInterfacePtr() : StatusOr_ExecutorInterfacePtr{inworld_StatusOr_ExecutorInterfacePtr_new()} {}
inline StatusOr_ExecutorInterfacePtr::StatusOr_ExecutorInterfacePtr(ExecutorInterface * value) : StatusOr_ExecutorInterfacePtr{inworld_StatusOr_ExecutorInterfacePtr_new_rcpinworld_graphs_ExecutorInterface(value->swig_self())} {}
inline StatusOr_ExecutorInterfacePtr::StatusOr_ExecutorInterfacePtr(Status const & status) : StatusOr_ExecutorInterfacePtr{inworld_StatusOr_ExecutorInterfacePtr_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_ExecutorInterfacePtr::ok() const { return inworld_StatusOr_ExecutorInterfacePtr_ok(swig_self()); }
inline Status StatusOr_ExecutorInterfacePtr::status() const {
  auto swig_cres = inworld_StatusOr_ExecutorInterfacePtr_status(swig_self());
  return Status{swig_cres, false};
}
inline ExecutorInterface * StatusOr_ExecutorInterfacePtr::value() const {
  auto swig_cres = inworld_StatusOr_ExecutorInterfacePtr_value(swig_self());
  return swig_cres ? new ExecutorInterface(swig_cres, false) : nullptr;
}
inline StatusOr_ExecutorInterfacePtr::StatusOr_ExecutorInterfacePtr(StatusOr_ExecutorInterfacePtr const & other) : StatusOr_ExecutorInterfacePtr{inworld_StatusOr_ExecutorInterfacePtr_copy(other.swig_self())} {}
inline StatusOr_GraphExecutorFactoryPtr::StatusOr_GraphExecutorFactoryPtr() : StatusOr_GraphExecutorFactoryPtr{inworld_StatusOr_GraphExecutorFactoryPtr_new()} {}
inline StatusOr_GraphExecutorFactoryPtr::StatusOr_GraphExecutorFactoryPtr(GraphExecutorFactory * value) : StatusOr_GraphExecutorFactoryPtr{inworld_StatusOr_GraphExecutorFactoryPtr_new_rcpinworld_graphs_GraphExecutorFactory(value->swig_self())} {}
inline StatusOr_GraphExecutorFactoryPtr::StatusOr_GraphExecutorFactoryPtr(Status const & status) : StatusOr_GraphExecutorFactoryPtr{inworld_StatusOr_GraphExecutorFactoryPtr_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_GraphExecutorFactoryPtr::ok() const { return inworld_StatusOr_GraphExecutorFactoryPtr_ok(swig_self()); }
inline Status StatusOr_GraphExecutorFactoryPtr::status() const {
  auto swig_cres = inworld_StatusOr_GraphExecutorFactoryPtr_status(swig_self());
  return Status{swig_cres, false};
}
inline GraphExecutorFactory * StatusOr_GraphExecutorFactoryPtr::value() const {
  auto swig_cres = inworld_StatusOr_GraphExecutorFactoryPtr_value(swig_self());
  return swig_cres ? new GraphExecutorFactory(swig_cres, false) : nullptr;
}
inline StatusOr_GraphExecutorFactoryPtr::StatusOr_GraphExecutorFactoryPtr(StatusOr_GraphExecutorFactoryPtr const & other) : StatusOr_GraphExecutorFactoryPtr{inworld_StatusOr_GraphExecutorFactoryPtr_copy(other.swig_self())} {}
inline Optional_ThreadPoolConfig::Optional_ThreadPoolConfig() : Optional_ThreadPoolConfig{inworld_Optional_ThreadPoolConfig_new()} {}
inline Optional_ThreadPoolConfig::Optional_ThreadPoolConfig(ThreadPoolConfig const & value) : Optional_ThreadPoolConfig{inworld_Optional_ThreadPoolConfig_new_rcinworld_graphs_ThreadPoolConfig(value.swig_self())} {}
inline Optional_ThreadPoolConfig::Optional_ThreadPoolConfig(Optional_ThreadPoolConfig const & other) : Optional_ThreadPoolConfig{inworld_Optional_ThreadPoolConfig_copy(other.swig_self())} {}
inline bool Optional_ThreadPoolConfig::has_value() const { return inworld_Optional_ThreadPoolConfig_has_value(swig_self()); }
inline ThreadPoolConfig Optional_ThreadPoolConfig::value() {
  auto swig_cres = inworld_Optional_ThreadPoolConfig_value(swig_self());
  return ThreadPoolConfig{swig_cres, false};
}
inline ThreadPoolConfig Optional_ThreadPoolConfig::value() const {
  auto swig_cres = inworld_Optional_ThreadPoolConfig_valueConst(swig_self());
  return ThreadPoolConfig{swig_cres, false};
}
inline ThreadPoolConfig Optional_ThreadPoolConfig::value_or(ThreadPoolConfig const & default_value) const {
  auto swig_cres = inworld_Optional_ThreadPoolConfig_value_or(swig_self(), default_value.swig_self());
  return ThreadPoolConfig{swig_cres, true};
}
inline void Optional_ThreadPoolConfig::reset() { inworld_Optional_ThreadPoolConfig_reset(swig_self()); }
inline ThreadPoolConfig Optional_ThreadPoolConfig::operator *() {
  auto swig_cres = inworld_Optional_ThreadPoolConfig_get(swig_self());
  return ThreadPoolConfig{swig_cres, false};
}
inline ThreadPoolConfig Optional_ThreadPoolConfig::operator *() const {
  auto swig_cres = inworld_Optional_ThreadPoolConfig_getConst(swig_self());
  return ThreadPoolConfig{swig_cres, false};
}
inline ThreadPoolConfig Optional_ThreadPoolConfig::get_value() {
  auto swig_cres = inworld_Optional_ThreadPoolConfig_get_value(swig_self());
  return ThreadPoolConfig{swig_cres, false};
}
inline void Optional_ThreadPoolConfig::set_value(ThreadPoolConfig & t) { inworld_Optional_ThreadPoolConfig_set_value(swig_self(), t.swig_self()); }
inline void GraphManagerConfig::enable_remote_config(bool enable_remote_config) { inworld_GraphManagerConfig_enable_remote_config_set(swig_self(), enable_remote_config); }
inline bool GraphManagerConfig::enable_remote_config() const { return inworld_GraphManagerConfig_enable_remote_config_get(swig_self()); }
inline void GraphManagerConfig::poll_interval(Duration * poll_interval) { inworld_GraphManagerConfig_poll_interval_set(swig_self(), poll_interval->swig_self()); }
inline Duration * GraphManagerConfig::poll_interval() const {
  auto swig_cres = inworld_GraphManagerConfig_poll_interval_get(swig_self());
  return swig_cres ? new Duration(swig_cres, false) : nullptr;
}
inline void GraphManagerConfig::address(std::string const& address) { inworld_GraphManagerConfig_address_set(swig_self(), (&address)->c_str()); }
inline std::string GraphManagerConfig::address() const {
  auto swig_cres = inworld_GraphManagerConfig_address_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void GraphManagerConfig::inworld_api_key(std::string const& inworld_api_key) { inworld_GraphManagerConfig_inworld_api_key_set(swig_self(), (&inworld_api_key)->c_str()); }
inline std::string GraphManagerConfig::inworld_api_key() const {
  auto swig_cres = inworld_GraphManagerConfig_inworld_api_key_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void GraphManagerConfig::evaluation_mode(GraphManagerConfig::EvaluationMode evaluation_mode) { inworld_GraphManagerConfig_evaluation_mode_set(swig_self(), (inworld_GraphManagerConfig_EvaluationMode)evaluation_mode); }
inline GraphManagerConfig::EvaluationMode GraphManagerConfig::evaluation_mode() const {
  auto swig_cres = inworld_GraphManagerConfig_evaluation_mode_get(swig_self());
  return (GraphManagerConfig::EvaluationMode)swig_cres;
}
inline void GraphManagerConfig::config_environment_variables(HashMap_StringToString * config_environment_variables) { inworld_GraphManagerConfig_config_environment_variables_set(swig_self(), config_environment_variables->swig_self()); }
inline HashMap_StringToString * GraphManagerConfig::config_environment_variables() const {
  auto swig_cres = inworld_GraphManagerConfig_config_environment_variables_get(swig_self());
  return swig_cres ? new HashMap_StringToString(swig_cres, false) : nullptr;
}
inline GraphManagerConfig GraphManagerConfig::Default() {
  auto swig_cres = inworld_GraphManagerConfig_Default();
  return GraphManagerConfig{swig_cres, false};
}
inline GraphManagerConfig GraphManagerConfig::WithDisabledRemoteConfig() {
  auto swig_cres = inworld_GraphManagerConfig_WithDisabledRemoteConfig();
  return GraphManagerConfig{swig_cres, true};
}
inline GraphManagerConfig GraphManagerConfig::WithRemoteConfig(std::string const& address, std::string const& arg2, Duration const& arg3, GraphManagerConfig::EvaluationMode arg4) {
  auto swig_cres = inworld_GraphManagerConfig_WithRemoteConfig_rcstd_string_rcstd_string_absl_Duration_eEvaluationMode((&address)->c_str(), (&arg2)->c_str(), arg3.swig_self(), (inworld_GraphManagerConfig_EvaluationMode)arg4);
  return GraphManagerConfig{swig_cres, true};
}
inline GraphManagerConfig GraphManagerConfig::WithRemoteConfig(std::string const& address, std::string const& arg2, Duration const& arg3) {
  auto swig_cres = inworld_GraphManagerConfig_WithRemoteConfig_rcstd_string_rcstd_string_absl_Duration((&address)->c_str(), (&arg2)->c_str(), arg3.swig_self());
  return GraphManagerConfig{swig_cres, true};
}
inline GraphManagerConfig GraphManagerConfig::WithRemoteConfig(std::string const& address, std::string const& arg2) {
  auto swig_cres = inworld_GraphManagerConfig_WithRemoteConfig_rcstd_string_rcstd_string((&address)->c_str(), (&arg2)->c_str());
  return GraphManagerConfig{swig_cres, true};
}
inline GraphManagerConfig::GraphManagerConfig() : GraphManagerConfig{inworld_GraphManagerConfig_new()} {}
inline GraphManagerConfig::GraphManagerConfig(GraphManagerConfig const & other) : GraphManagerConfig{inworld_GraphManagerConfig_copy(other.swig_self())} {}
inline void ThreadPoolConfig::worker_strategy(ThreadPoolConfig::WorkerCountStrategy worker_strategy) { inworld_ThreadPoolConfig_worker_strategy_set(swig_self(), (inworld_ThreadPoolConfig_WorkerCountStrategy)worker_strategy); }
inline ThreadPoolConfig::WorkerCountStrategy ThreadPoolConfig::worker_strategy() const {
  auto swig_cres = inworld_ThreadPoolConfig_worker_strategy_get(swig_self());
  return (ThreadPoolConfig::WorkerCountStrategy)swig_cres;
}
inline void ThreadPoolConfig::thread_pool_strategy(ThreadPoolConfig::ThreadPoolStrategy thread_pool_strategy) { inworld_ThreadPoolConfig_thread_pool_strategy_set(swig_self(), (inworld_ThreadPoolConfig_ThreadPoolStrategy)thread_pool_strategy); }
inline ThreadPoolConfig::ThreadPoolStrategy ThreadPoolConfig::thread_pool_strategy() const {
  auto swig_cres = inworld_ThreadPoolConfig_thread_pool_strategy_get(swig_self());
  return (ThreadPoolConfig::ThreadPoolStrategy)swig_cres;
}
inline void ThreadPoolConfig::worker_count(optional_sizet * worker_count) { inworld_ThreadPoolConfig_worker_count_set(swig_self(), worker_count->swig_self()); }
inline optional_sizet * ThreadPoolConfig::worker_count() const {
  auto swig_cres = inworld_ThreadPoolConfig_worker_count_get(swig_self());
  return swig_cres ? new optional_sizet(swig_cres, false) : nullptr;
}
inline void ThreadPoolConfig::core_multiplier(float core_multiplier) { inworld_ThreadPoolConfig_core_multiplier_set(swig_self(), core_multiplier); }
inline float ThreadPoolConfig::core_multiplier() const { return inworld_ThreadPoolConfig_core_multiplier_get(swig_self()); }
inline ThreadPoolConfig ThreadPoolConfig::Default() {
  auto swig_cres = inworld_ThreadPoolConfig_Default();
  return ThreadPoolConfig{swig_cres, true};
}
inline ThreadPoolConfig ThreadPoolConfig::WithFixedWorkers(size_t worker_count) {
  auto swig_cres = inworld_ThreadPoolConfig_WithFixedWorkers(worker_count);
  return ThreadPoolConfig{swig_cres, true};
}
inline ThreadPoolConfig ThreadPoolConfig::WithSystemCores(float multiplier) {
  auto swig_cres = inworld_ThreadPoolConfig_WithSystemCores_f(multiplier);
  return ThreadPoolConfig{swig_cres, true};
}
inline ThreadPoolConfig ThreadPoolConfig::WithSystemCores() {
  auto swig_cres = inworld_ThreadPoolConfig_WithSystemCores();
  return ThreadPoolConfig{swig_cres, true};
}
inline ThreadPoolConfig::ThreadPoolConfig() : ThreadPoolConfig{inworld_ThreadPoolConfig_new()} {}
inline ThreadPoolConfig::ThreadPoolConfig(ThreadPoolConfig const & other) : ThreadPoolConfig{inworld_ThreadPoolConfig_copy(other.swig_self())} {}
inline void GraphExecutorFactoryConfig::thread_pool_strategy(ThreadPoolConfig::ThreadPoolStrategy thread_pool_strategy) { inworld_GraphExecutorFactoryConfig_thread_pool_strategy_set(swig_self(), (inworld_ThreadPoolConfig_ThreadPoolStrategy)thread_pool_strategy); }
inline ThreadPoolConfig::ThreadPoolStrategy GraphExecutorFactoryConfig::thread_pool_strategy() const {
  auto swig_cres = inworld_GraphExecutorFactoryConfig_thread_pool_strategy_get(swig_self());
  return (ThreadPoolConfig::ThreadPoolStrategy)swig_cres;
}
inline void GraphExecutorFactoryConfig::thread_pool_config(ThreadPoolConfig * thread_pool_config) { inworld_GraphExecutorFactoryConfig_thread_pool_config_set(swig_self(), thread_pool_config->swig_self()); }
inline ThreadPoolConfig * GraphExecutorFactoryConfig::thread_pool_config() const {
  auto swig_cres = inworld_GraphExecutorFactoryConfig_thread_pool_config_get(swig_self());
  return swig_cres ? new ThreadPoolConfig(swig_cres, false) : nullptr;
}
inline GraphExecutorFactoryConfig GraphExecutorFactoryConfig::Default() {
  auto swig_cres = inworld_GraphExecutorFactoryConfig_Default();
  return GraphExecutorFactoryConfig{swig_cres, true};
}
inline GraphExecutorFactoryConfig GraphExecutorFactoryConfig::WithSharedThreadPool(ThreadPoolConfig const & thread_pool_config) {
  auto swig_cres = inworld_GraphExecutorFactoryConfig_WithSharedThreadPool(thread_pool_config.swig_self());
  return GraphExecutorFactoryConfig{swig_cres, true};
}
inline GraphExecutorFactoryConfig GraphExecutorFactoryConfig::WithDedicatedThreadPool(ThreadPoolConfig const & thread_pool_config) {
  auto swig_cres = inworld_GraphExecutorFactoryConfig_WithDedicatedThreadPool(thread_pool_config.swig_self());
  return GraphExecutorFactoryConfig{swig_cres, true};
}
inline GraphExecutorFactoryConfig::GraphExecutorFactoryConfig() : GraphExecutorFactoryConfig{inworld_GraphExecutorFactoryConfig_new()} {}
inline GraphExecutorFactoryConfig::GraphExecutorFactoryConfig(GraphExecutorFactoryConfig const & other) : GraphExecutorFactoryConfig{inworld_GraphExecutorFactoryConfig_copy(other.swig_self())} {}
inline void GraphExecutorConfig::graph_manager_config(GraphManagerConfig * graph_manager_config) { inworld_GraphExecutorConfig_graph_manager_config_set(swig_self(), graph_manager_config->swig_self()); }
inline GraphManagerConfig * GraphExecutorConfig::graph_manager_config() const {
  auto swig_cres = inworld_GraphExecutorConfig_graph_manager_config_get(swig_self());
  return swig_cres ? new GraphManagerConfig(swig_cres, false) : nullptr;
}
inline void GraphExecutorConfig::thread_pool_config_override(Optional_ThreadPoolConfig * thread_pool_config_override) { inworld_GraphExecutorConfig_thread_pool_config_override_set(swig_self(), thread_pool_config_override->swig_self()); }
inline Optional_ThreadPoolConfig * GraphExecutorConfig::thread_pool_config_override() const {
  auto swig_cres = inworld_GraphExecutorConfig_thread_pool_config_override_get(swig_self());
  return swig_cres ? new Optional_ThreadPoolConfig(swig_cres, false) : nullptr;
}
inline GraphExecutorConfig GraphExecutorConfig::Default() {
  auto swig_cres = inworld_GraphExecutorConfig_Default();
  return GraphExecutorConfig{swig_cres, true};
}
inline GraphExecutorConfig GraphExecutorConfig::WithGraphManager(GraphManagerConfig const & graph_manager_config) {
  auto swig_cres = inworld_GraphExecutorConfig_WithGraphManager(graph_manager_config.swig_self());
  return GraphExecutorConfig{swig_cres, true};
}
inline GraphExecutorConfig GraphExecutorConfig::WithLocalGraphManager() {
  auto swig_cres = inworld_GraphExecutorConfig_WithLocalGraphManager();
  return GraphExecutorConfig{swig_cres, true};
}
inline GraphExecutorConfig::GraphExecutorConfig() : GraphExecutorConfig{inworld_GraphExecutorConfig_new()} {}
inline GraphExecutorConfig::GraphExecutorConfig(GraphExecutorConfig const & other) : GraphExecutorConfig{inworld_GraphExecutorConfig_copy(other.swig_self())} {}
inline StatusOr_GraphExecutorFactoryPtr GraphExecutorFactory::inworld_inworld_graphs_GraphExecutorFactory_CreateHelper__SWIG_0() {
  auto swig_cres = inworld_GraphExecutorFactory_CreateHelper();
  return StatusOr_GraphExecutorFactoryPtr{swig_cres, true};
}
inline StatusOr_GraphExecutorFactoryPtr GraphExecutorFactory::inworld_inworld_graphs_GraphExecutorFactory_CreateHelper__SWIG_1(GraphExecutorFactoryConfig const & config) {
  auto swig_cres = inworld_GraphExecutorFactory_CreateHelper_rcinworld_graphs_GraphExecutorFactoryConfig(config.swig_self());
  return StatusOr_GraphExecutorFactoryPtr{swig_cres, true};
}
inline StatusOr_ExecutorInterfacePtr GraphExecutorFactory::CreateExecutorHelper(CompiledGraphInterface * graphs) {
  auto swig_cres = inworld_GraphExecutorFactory_CreateExecutorHelper_pinworld_graphs_CompiledGraphInterface(swig_self(), graphs->swig_self());
  return StatusOr_ExecutorInterfacePtr{swig_cres, true};
}
inline StatusOr_ExecutorInterfacePtr GraphExecutorFactory::CreateExecutorHelper(CompiledGraphInterface * graphs, GraphExecutorConfig const & arg3) {
  auto swig_cres = inworld_GraphExecutorFactory_CreateExecutorHelper_pinworld_graphs_CompiledGraphInterface_rcinworld_graphs_GraphExecutorConfig(swig_self(), graphs->swig_self(), arg3.swig_self());
  return StatusOr_ExecutorInterfacePtr{swig_cres, true};
}
inline void FeedbackRecorder::RecordFeedback(std::string const& graph_id, std::string const& arg2, std::string const& arg3, std::string const& arg4) { inworld_FeedbackRecorder_RecordFeedback((&graph_id)->c_str(), (&arg2)->c_str(), (&arg3)->c_str(), (&arg4)->c_str()); }
inline FeedbackRecorder::FeedbackRecorder(FeedbackRecorder const & other) : FeedbackRecorder{inworld_FeedbackRecorder_copy(other.swig_self())} {}
inline void MCPHttpAuthConfig::api_key(std::string const& api_key) { inworld_MCPHttpAuthConfig_api_key_set(swig_self(), (&api_key)->c_str()); }
inline std::string MCPHttpAuthConfig::api_key() const {
  auto swig_cres = inworld_MCPHttpAuthConfig_api_key_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline MCPHttpAuthConfig::MCPHttpAuthConfig() : MCPHttpAuthConfig{inworld_MCPHttpAuthConfig_new()} {}
inline MCPHttpAuthConfig::MCPHttpAuthConfig(MCPHttpAuthConfig const & other) : MCPHttpAuthConfig{inworld_MCPHttpAuthConfig_copy(other.swig_self())} {}
inline void ParagonApiAuthConfig::jwt_token(std::string const& jwt_token) { inworld_ParagonApiAuthConfig_jwt_token_set(swig_self(), (&jwt_token)->c_str()); }
inline std::string ParagonApiAuthConfig::jwt_token() const {
  auto swig_cres = inworld_ParagonApiAuthConfig_jwt_token_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline ParagonApiAuthConfig::ParagonApiAuthConfig() : ParagonApiAuthConfig{inworld_ParagonApiAuthConfig_new()} {}
inline ParagonApiAuthConfig::ParagonApiAuthConfig(ParagonApiAuthConfig const & other) : ParagonApiAuthConfig{inworld_ParagonApiAuthConfig_copy(other.swig_self())} {}
inline void MCPStdioAuthConfig::set(std::string const& key, std::string const& arg3) { inworld_MCPStdioAuthConfig_set(swig_self(), (&key)->c_str(), (&arg3)->c_str()); }
inline MCPStdioAuthConfig::MCPStdioAuthConfig() : MCPStdioAuthConfig{inworld_MCPStdioAuthConfig_new()} {}
inline MCPStdioAuthConfig::MCPStdioAuthConfig(MCPStdioAuthConfig const & other) : MCPStdioAuthConfig{inworld_MCPStdioAuthConfig_copy(other.swig_self())} {}
inline void MCPAuthConfig::set_http_auth_config(MCPHttpAuthConfig const & config) { inworld_MCPAuthConfig_set_http_auth_config(swig_self(), config.swig_self()); }
inline void MCPAuthConfig::set_stdio_auth_config(MCPStdioAuthConfig const & config) { inworld_MCPAuthConfig_set_stdio_auth_config(swig_self(), config.swig_self()); }
inline void MCPAuthConfig::set_paragon_api_auth_config(ParagonApiAuthConfig const & config) { inworld_MCPAuthConfig_set_paragon_api_auth_config(swig_self(), config.swig_self()); }
inline MCPAuthConfig::MCPAuthConfig() : MCPAuthConfig{inworld_MCPAuthConfig_new()} {}
inline MCPAuthConfig::MCPAuthConfig(MCPAuthConfig const & other) : MCPAuthConfig{inworld_MCPAuthConfig_copy(other.swig_self())} {}
inline void MCPSessionCreationConfig::transport(std::string const& transport) { inworld_MCPSessionCreationConfig_transport_set(swig_self(), (&transport)->c_str()); }
inline std::string MCPSessionCreationConfig::transport() const {
  auto swig_cres = inworld_MCPSessionCreationConfig_transport_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void MCPSessionCreationConfig::endpoint(std::string const& endpoint) { inworld_MCPSessionCreationConfig_endpoint_set(swig_self(), (&endpoint)->c_str()); }
inline std::string MCPSessionCreationConfig::endpoint() const {
  auto swig_cres = inworld_MCPSessionCreationConfig_endpoint_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void MCPSessionCreationConfig::auth_config(MCPAuthConfig * auth_config) { inworld_MCPSessionCreationConfig_auth_config_set(swig_self(), auth_config->swig_self()); }
inline MCPAuthConfig * MCPSessionCreationConfig::auth_config() const {
  auto swig_cres = inworld_MCPSessionCreationConfig_auth_config_get(swig_self());
  return swig_cres ? new MCPAuthConfig(swig_cres, false) : nullptr;
}
inline MCPSessionCreationConfig::MCPSessionCreationConfig() : MCPSessionCreationConfig{inworld_MCPSessionCreationConfig_new()} {}
inline MCPSessionCreationConfig::MCPSessionCreationConfig(MCPSessionCreationConfig const & other) : MCPSessionCreationConfig{inworld_MCPSessionCreationConfig_copy(other.swig_self())} {}
inline void MCPClientCreationConfig::session_config(MCPSessionCreationConfig * session_config) { inworld_MCPClientCreationConfig_session_config_set(swig_self(), session_config->swig_self()); }
inline MCPSessionCreationConfig * MCPClientCreationConfig::session_config() const {
  auto swig_cres = inworld_MCPClientCreationConfig_session_config_get(swig_self());
  return swig_cres ? new MCPSessionCreationConfig(swig_cres, false) : nullptr;
}
inline MCPClientCreationConfig::MCPClientCreationConfig() : MCPClientCreationConfig{inworld_MCPClientCreationConfig_new()} {}
inline MCPClientCreationConfig::MCPClientCreationConfig(MCPClientCreationConfig const & other) : MCPClientCreationConfig{inworld_MCPClientCreationConfig_copy(other.swig_self())} {}
inline StatusOr_MCPClientInterface MCPClientFactory::CreateMCPClient(MCPClientCreationConfig const & config) {
  auto swig_cres = inworld_MCPClientFactory_CreateMCPClient(swig_self(), config.swig_self());
  return StatusOr_MCPClientInterface{swig_cres, true};
}
inline MCPClientFactory::MCPClientFactory() : MCPClientFactory{inworld_MCPClientFactory_new()} {}
inline MCPClientFactory::MCPClientFactory(MCPClientFactory const & other) : MCPClientFactory{inworld_MCPClientFactory_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_EmbeddingMatcherNode::StatusOr_SharedPtr_EmbeddingMatcherNode() : StatusOr_SharedPtr_EmbeddingMatcherNode{inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_new()} {}
inline StatusOr_SharedPtr_EmbeddingMatcherNode::StatusOr_SharedPtr_EmbeddingMatcherNode(EmbeddingMatcherNode const& value) : StatusOr_SharedPtr_EmbeddingMatcherNode{inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_new_rcstd_shared_ptr_Sl_inworld_graphs_EmbeddingMatcherNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_EmbeddingMatcherNode::StatusOr_SharedPtr_EmbeddingMatcherNode(Status const & status) : StatusOr_SharedPtr_EmbeddingMatcherNode{inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_EmbeddingMatcherNode::ok() const { return inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_EmbeddingMatcherNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_status(swig_self());
  return Status{swig_cres, false};
}
inline EmbeddingMatcherNode StatusOr_SharedPtr_EmbeddingMatcherNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_value(swig_self());
  return EmbeddingMatcherNode{swig_cres, true};
}
inline StatusOr_SharedPtr_EmbeddingMatcherNode::StatusOr_SharedPtr_EmbeddingMatcherNode(StatusOr_SharedPtr_EmbeddingMatcherNode const & other) : StatusOr_SharedPtr_EmbeddingMatcherNode{inworld_StatusOr_SharedPtr_EmbeddingMatcherNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_MatchedPhrases::StatusOr_SharedPtr_MatchedPhrases() : StatusOr_SharedPtr_MatchedPhrases{inworld_StatusOr_SharedPtr_MatchedPhrases_new()} {}
inline StatusOr_SharedPtr_MatchedPhrases::StatusOr_SharedPtr_MatchedPhrases(MatchedPhrases const& value) : StatusOr_SharedPtr_MatchedPhrases{inworld_StatusOr_SharedPtr_MatchedPhrases_new_rcstd_shared_ptr_Sl_inworld_graphs_MatchedPhrases_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_MatchedPhrases::StatusOr_SharedPtr_MatchedPhrases(Status const & status) : StatusOr_SharedPtr_MatchedPhrases{inworld_StatusOr_SharedPtr_MatchedPhrases_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_MatchedPhrases::ok() const { return inworld_StatusOr_SharedPtr_MatchedPhrases_ok(swig_self()); }
inline Status StatusOr_SharedPtr_MatchedPhrases::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MatchedPhrases_status(swig_self());
  return Status{swig_cres, false};
}
inline MatchedPhrases StatusOr_SharedPtr_MatchedPhrases::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MatchedPhrases_value(swig_self());
  return MatchedPhrases{swig_cres, true};
}
inline StatusOr_SharedPtr_MatchedPhrases::StatusOr_SharedPtr_MatchedPhrases(StatusOr_SharedPtr_MatchedPhrases const & other) : StatusOr_SharedPtr_MatchedPhrases{inworld_StatusOr_SharedPtr_MatchedPhrases_copy(other.swig_self())} {}
inline void EmbeddingMatcherNodeCreationConfig::phrases(vector_string * phrases) { inworld_EmbeddingMatcherNodeCreationConfig_phrases_set(swig_self(), phrases->swig_self()); }
inline vector_string * EmbeddingMatcherNodeCreationConfig::phrases() const {
  auto swig_cres = inworld_EmbeddingMatcherNodeCreationConfig_phrases_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline void EmbeddingMatcherNodeCreationConfig::embedder_component_id(std::string const& embedder_component_id) { inworld_EmbeddingMatcherNodeCreationConfig_embedder_component_id_set(swig_self(), (&embedder_component_id)->c_str()); }
inline std::string EmbeddingMatcherNodeCreationConfig::embedder_component_id() const {
  auto swig_cres = inworld_EmbeddingMatcherNodeCreationConfig_embedder_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline EmbeddingMatcherNodeCreationConfig::EmbeddingMatcherNodeCreationConfig() : EmbeddingMatcherNodeCreationConfig{inworld_EmbeddingMatcherNodeCreationConfig_new()} {}
inline EmbeddingMatcherNodeCreationConfig::EmbeddingMatcherNodeCreationConfig(EmbeddingMatcherNodeCreationConfig const & other) : EmbeddingMatcherNodeCreationConfig{inworld_EmbeddingMatcherNodeCreationConfig_copy(other.swig_self())} {}
inline void EmbeddingMatcherNodeExecutionConfig::similarity_threshold(float similarity_threshold) { inworld_EmbeddingMatcherNodeExecutionConfig_similarity_threshold_set(swig_self(), similarity_threshold); }
inline float EmbeddingMatcherNodeExecutionConfig::similarity_threshold() const { return inworld_EmbeddingMatcherNodeExecutionConfig_similarity_threshold_get(swig_self()); }
inline void EmbeddingMatcherNodeExecutionConfig::top_n(size_t top_n) { inworld_EmbeddingMatcherNodeExecutionConfig_top_n_set(swig_self(), top_n); }
inline size_t EmbeddingMatcherNodeExecutionConfig::top_n() const { return inworld_EmbeddingMatcherNodeExecutionConfig_top_n_get(swig_self()); }
inline bool EmbeddingMatcherNodeExecutionConfig::is_valid() const { return inworld_EmbeddingMatcherNodeExecutionConfig_is_valid(swig_self()); }
inline EmbeddingMatcherNodeExecutionConfig::EmbeddingMatcherNodeExecutionConfig() : EmbeddingMatcherNodeExecutionConfig{inworld_EmbeddingMatcherNodeExecutionConfig_new()} {}
inline EmbeddingMatcherNodeExecutionConfig::EmbeddingMatcherNodeExecutionConfig(EmbeddingMatcherNodeExecutionConfig const & other) : EmbeddingMatcherNodeExecutionConfig{inworld_EmbeddingMatcherNodeExecutionConfig_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_EmbeddingMatcherNode EmbeddingMatcherNode::Create(std::string const& id, CreationContext const & arg2, EmbeddingMatcherNodeCreationConfig const & arg3, EmbeddingMatcherNodeExecutionConfig const & arg4) {
  auto swig_cres = inworld_EmbeddingMatcherNode_Create((&id)->c_str(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_SharedPtr_EmbeddingMatcherNode{swig_cres, true};
}
inline bool EmbeddingMatcherNode::is_valid() const { return inworld_EmbeddingMatcherNode_is_valid(swig_self()); }
inline EmbeddingMatcherNode::EmbeddingMatcherNode(EmbeddingMatcherNode const & other) : EmbeddingMatcherNode{inworld_EmbeddingMatcherNode_copy(other.swig_self())} {}
inline optional_Condition::optional_Condition() : optional_Condition{inworld_optional_Condition_new()} {}
inline optional_Condition::optional_Condition(Condition const & value) : optional_Condition{inworld_optional_Condition_new_rcinworld_graphs_Condition(value.swig_self())} {}
inline optional_Condition::optional_Condition(optional_Condition const & other) : optional_Condition{inworld_optional_Condition_copy(other.swig_self())} {}
inline bool optional_Condition::has_value() const { return inworld_optional_Condition_has_value(swig_self()); }
inline Condition optional_Condition::value() {
  auto swig_cres = inworld_optional_Condition_value(swig_self());
  return Condition{swig_cres, false};
}
inline Condition optional_Condition::value() const {
  auto swig_cres = inworld_optional_Condition_valueConst(swig_self());
  return Condition{swig_cres, false};
}
inline Condition optional_Condition::value_or(Condition const & default_value) const {
  auto swig_cres = inworld_optional_Condition_value_or(swig_self(), default_value.swig_self());
  return Condition{swig_cres, true};
}
inline void optional_Condition::reset() { inworld_optional_Condition_reset(swig_self()); }
inline Condition optional_Condition::operator *() {
  auto swig_cres = inworld_optional_Condition_get(swig_self());
  return Condition{swig_cres, false};
}
inline Condition optional_Condition::operator *() const {
  auto swig_cres = inworld_optional_Condition_getConst(swig_self());
  return Condition{swig_cres, false};
}
inline Condition optional_Condition::get_value() {
  auto swig_cres = inworld_optional_Condition_get_value(swig_self());
  return Condition{swig_cres, false};
}
inline void optional_Condition::set_value(Condition & t) { inworld_optional_Condition_set_value(swig_self(), t.swig_self()); }
inline void Condition::intents(vector_string * intents) { inworld_Condition_intents_set(swig_self(), intents->swig_self()); }
inline vector_string * Condition::intents() const {
  auto swig_cres = inworld_Condition_intents_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline void Condition::detect(optional_string * detect) { inworld_Condition_detect_set(swig_self(), detect->swig_self()); }
inline optional_string * Condition::detect() const {
  auto swig_cres = inworld_Condition_detect_get(swig_self());
  return swig_cres ? new optional_string(swig_cres, false) : nullptr;
}
inline void Condition::required_goals(vector_string * required_goals) { inworld_Condition_required_goals_set(swig_self(), required_goals->swig_self()); }
inline vector_string * Condition::required_goals() const {
  auto swig_cres = inworld_Condition_required_goals_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline Condition::Condition() : Condition{inworld_Condition_new()} {}
inline Condition::Condition(Condition const & other) : Condition{inworld_Condition_copy(other.swig_self())} {}
inline void Goal::name(std::string const& name) { inworld_Goal_name_set(swig_self(), (&name)->c_str()); }
inline std::string Goal::name() const {
  auto swig_cres = inworld_Goal_name_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void Goal::motivation(optional_string * motivation) { inworld_Goal_motivation_set(swig_self(), motivation->swig_self()); }
inline optional_string * Goal::motivation() const {
  auto swig_cres = inworld_Goal_motivation_get(swig_self());
  return swig_cres ? new optional_string(swig_cres, false) : nullptr;
}
inline void Goal::repeatable(bool repeatable) { inworld_Goal_repeatable_set(swig_self(), repeatable); }
inline bool Goal::repeatable() const { return inworld_Goal_repeatable_get(swig_self()); }
inline void Goal::activation_condition(optional_Condition * activation_condition) { inworld_Goal_activation_condition_set(swig_self(), activation_condition->swig_self()); }
inline optional_Condition * Goal::activation_condition() const {
  auto swig_cres = inworld_Goal_activation_condition_get(swig_self());
  return swig_cres ? new optional_Condition(swig_cres, false) : nullptr;
}
inline void Goal::completion_condition(optional_Condition * completion_condition) { inworld_Goal_completion_condition_set(swig_self(), completion_condition->swig_self()); }
inline optional_Condition * Goal::completion_condition() const {
  auto swig_cres = inworld_Goal_completion_condition_get(swig_self());
  return swig_cres ? new optional_Condition(swig_cres, false) : nullptr;
}
inline Goal::Goal() : Goal{inworld_Goal_new()} {}
inline Goal::Goal(Goal const & other) : Goal{inworld_Goal_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_GoalAdvancementNode::StatusOr_SharedPtr_GoalAdvancementNode() : StatusOr_SharedPtr_GoalAdvancementNode{inworld_StatusOr_SharedPtr_GoalAdvancementNode_new()} {}
inline StatusOr_SharedPtr_GoalAdvancementNode::StatusOr_SharedPtr_GoalAdvancementNode(GoalAdvancementNode const& value) : StatusOr_SharedPtr_GoalAdvancementNode{inworld_StatusOr_SharedPtr_GoalAdvancementNode_new_rcstd_shared_ptr_Sl_inworld_graphs_GoalAdvancementNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_GoalAdvancementNode::StatusOr_SharedPtr_GoalAdvancementNode(Status const & status) : StatusOr_SharedPtr_GoalAdvancementNode{inworld_StatusOr_SharedPtr_GoalAdvancementNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_GoalAdvancementNode::ok() const { return inworld_StatusOr_SharedPtr_GoalAdvancementNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_GoalAdvancementNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_GoalAdvancementNode_status(swig_self());
  return Status{swig_cres, false};
}
inline GoalAdvancementNode StatusOr_SharedPtr_GoalAdvancementNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_GoalAdvancementNode_value(swig_self());
  return GoalAdvancementNode{swig_cres, true};
}
inline StatusOr_SharedPtr_GoalAdvancementNode::StatusOr_SharedPtr_GoalAdvancementNode(StatusOr_SharedPtr_GoalAdvancementNode const & other) : StatusOr_SharedPtr_GoalAdvancementNode{inworld_StatusOr_SharedPtr_GoalAdvancementNode_copy(other.swig_self())} {}
inline vector_Goal::vector_Goal() : vector_Goal{inworld_vector_Goal_new()} {}
inline vector_Goal::vector_Goal(vector_Goal const & other) : vector_Goal{inworld_vector_Goal_copy(other.swig_self())} {}
inline size_t vector_Goal::size() const { return inworld_vector_Goal_size(swig_self()); }
inline size_t vector_Goal::capacity() const { return inworld_vector_Goal_capacity(swig_self()); }
inline void vector_Goal::reserve(size_t n) { inworld_vector_Goal_reserve(swig_self(), n); }
inline bool vector_Goal::empty() const { return inworld_vector_Goal_empty(swig_self()); }
inline void vector_Goal::clear() { inworld_vector_Goal_clear(swig_self()); }
inline void vector_Goal::push_back(Goal const & x) { inworld_vector_Goal_push_back(swig_self(), x.swig_self()); }
inline Goal vector_Goal::get(int i) {
  auto swig_cres = inworld_vector_Goal_get(swig_self(), i);
  return Goal{swig_cres, false};
}
inline void vector_Goal::set(int i, Goal const & arg3) { inworld_vector_Goal_set(swig_self(), i, arg3.swig_self()); }
inline void GoalAdvancementNodeCreationConfig::goals(vector_Goal * goals) { inworld_GoalAdvancementNodeCreationConfig_goals_set(swig_self(), goals->swig_self()); }
inline vector_Goal * GoalAdvancementNodeCreationConfig::goals() const {
  auto swig_cres = inworld_GoalAdvancementNodeCreationConfig_goals_get(swig_self());
  return swig_cres ? new vector_Goal(swig_cres, false) : nullptr;
}
inline GoalAdvancementNodeCreationConfig::GoalAdvancementNodeCreationConfig() : GoalAdvancementNodeCreationConfig{inworld_GoalAdvancementNodeCreationConfig_new()} {}
inline GoalAdvancementNodeCreationConfig::GoalAdvancementNodeCreationConfig(GoalAdvancementNodeCreationConfig const & other) : GoalAdvancementNodeCreationConfig{inworld_GoalAdvancementNodeCreationConfig_copy(other.swig_self())} {}
inline void GoalAdvancementNodeExecutionConfig::llm_component_id(std::string const& llm_component_id) { inworld_GoalAdvancementNodeExecutionConfig_llm_component_id_set(swig_self(), (&llm_component_id)->c_str()); }
inline std::string GoalAdvancementNodeExecutionConfig::llm_component_id() const {
  auto swig_cres = inworld_GoalAdvancementNodeExecutionConfig_llm_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void GoalAdvancementNodeExecutionConfig::text_generation_config(optional_TextGenerationConfig * text_generation_config) { inworld_GoalAdvancementNodeExecutionConfig_text_generation_config_set(swig_self(), text_generation_config->swig_self()); }
inline optional_TextGenerationConfig * GoalAdvancementNodeExecutionConfig::text_generation_config() const {
  auto swig_cres = inworld_GoalAdvancementNodeExecutionConfig_text_generation_config_get(swig_self());
  return swig_cres ? new optional_TextGenerationConfig(swig_cres, false) : nullptr;
}
inline bool GoalAdvancementNodeExecutionConfig::is_valid() const { return inworld_GoalAdvancementNodeExecutionConfig_is_valid(swig_self()); }
inline GoalAdvancementNodeExecutionConfig::GoalAdvancementNodeExecutionConfig() : GoalAdvancementNodeExecutionConfig{inworld_GoalAdvancementNodeExecutionConfig_new()} {}
inline GoalAdvancementNodeExecutionConfig::GoalAdvancementNodeExecutionConfig(GoalAdvancementNodeExecutionConfig const & other) : GoalAdvancementNodeExecutionConfig{inworld_GoalAdvancementNodeExecutionConfig_copy(other.swig_self())} {}
inline bool GoalAdvancementNode::is_valid() const { return inworld_GoalAdvancementNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_GoalAdvancementNode GoalAdvancementNode::inworld_inworld_graphs_GoalAdvancementNode_Create__SWIG(std::string const& id, GoalAdvancementNodeCreationConfig const & arg2, GoalAdvancementNodeExecutionConfig const& arg3) {
  auto swig_cres = inworld_GoalAdvancementNode_Create((&id)->c_str(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_SharedPtr_GoalAdvancementNode{swig_cres, true};
}
inline StatusOr_SharedPtr_IntentNode::StatusOr_SharedPtr_IntentNode() : StatusOr_SharedPtr_IntentNode{inworld_StatusOr_SharedPtr_IntentNode_new()} {}
inline StatusOr_SharedPtr_IntentNode::StatusOr_SharedPtr_IntentNode(IntentNode const& value) : StatusOr_SharedPtr_IntentNode{inworld_StatusOr_SharedPtr_IntentNode_new_rcstd_shared_ptr_Sl_inworld_graphs_IntentNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_IntentNode::StatusOr_SharedPtr_IntentNode(Status const & status) : StatusOr_SharedPtr_IntentNode{inworld_StatusOr_SharedPtr_IntentNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_IntentNode::ok() const { return inworld_StatusOr_SharedPtr_IntentNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_IntentNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_IntentNode_status(swig_self());
  return Status{swig_cres, false};
}
inline IntentNode StatusOr_SharedPtr_IntentNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_IntentNode_value(swig_self());
  return IntentNode{swig_cres, true};
}
inline StatusOr_SharedPtr_IntentNode::StatusOr_SharedPtr_IntentNode(StatusOr_SharedPtr_IntentNode const & other) : StatusOr_SharedPtr_IntentNode{inworld_StatusOr_SharedPtr_IntentNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_MatchedIntents::StatusOr_SharedPtr_MatchedIntents() : StatusOr_SharedPtr_MatchedIntents{inworld_StatusOr_SharedPtr_MatchedIntents_new()} {}
inline StatusOr_SharedPtr_MatchedIntents::StatusOr_SharedPtr_MatchedIntents(MatchedIntents const& value) : StatusOr_SharedPtr_MatchedIntents{inworld_StatusOr_SharedPtr_MatchedIntents_new_rcstd_shared_ptr_Sl_inworld_graphs_MatchedIntents_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_MatchedIntents::StatusOr_SharedPtr_MatchedIntents(Status const & status) : StatusOr_SharedPtr_MatchedIntents{inworld_StatusOr_SharedPtr_MatchedIntents_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_MatchedIntents::ok() const { return inworld_StatusOr_SharedPtr_MatchedIntents_ok(swig_self()); }
inline Status StatusOr_SharedPtr_MatchedIntents::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MatchedIntents_status(swig_self());
  return Status{swig_cres, false};
}
inline MatchedIntents StatusOr_SharedPtr_MatchedIntents::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MatchedIntents_value(swig_self());
  return MatchedIntents{swig_cres, true};
}
inline StatusOr_SharedPtr_MatchedIntents::StatusOr_SharedPtr_MatchedIntents(StatusOr_SharedPtr_MatchedIntents const & other) : StatusOr_SharedPtr_MatchedIntents{inworld_StatusOr_SharedPtr_MatchedIntents_copy(other.swig_self())} {}
inline optional_TextEmbedderCreationConfig::optional_TextEmbedderCreationConfig() : optional_TextEmbedderCreationConfig{inworld_optional_TextEmbedderCreationConfig_new()} {}
inline optional_TextEmbedderCreationConfig::optional_TextEmbedderCreationConfig(TextEmbedderCreationConfig const & value) : optional_TextEmbedderCreationConfig{inworld_optional_TextEmbedderCreationConfig_new_rcinworld_TextEmbedderCreationConfig(value.swig_self())} {}
inline optional_TextEmbedderCreationConfig::optional_TextEmbedderCreationConfig(optional_TextEmbedderCreationConfig const & other) : optional_TextEmbedderCreationConfig{inworld_optional_TextEmbedderCreationConfig_copy(other.swig_self())} {}
inline bool optional_TextEmbedderCreationConfig::has_value() const { return inworld_optional_TextEmbedderCreationConfig_has_value(swig_self()); }
inline TextEmbedderCreationConfig optional_TextEmbedderCreationConfig::value() {
  auto swig_cres = inworld_optional_TextEmbedderCreationConfig_value(swig_self());
  return TextEmbedderCreationConfig{swig_cres, false};
}
inline TextEmbedderCreationConfig optional_TextEmbedderCreationConfig::value() const {
  auto swig_cres = inworld_optional_TextEmbedderCreationConfig_valueConst(swig_self());
  return TextEmbedderCreationConfig{swig_cres, false};
}
inline TextEmbedderCreationConfig optional_TextEmbedderCreationConfig::value_or(TextEmbedderCreationConfig const & default_value) const {
  auto swig_cres = inworld_optional_TextEmbedderCreationConfig_value_or(swig_self(), default_value.swig_self());
  return TextEmbedderCreationConfig{swig_cres, true};
}
inline void optional_TextEmbedderCreationConfig::reset() { inworld_optional_TextEmbedderCreationConfig_reset(swig_self()); }
inline TextEmbedderCreationConfig optional_TextEmbedderCreationConfig::operator *() {
  auto swig_cres = inworld_optional_TextEmbedderCreationConfig_get(swig_self());
  return TextEmbedderCreationConfig{swig_cres, false};
}
inline TextEmbedderCreationConfig optional_TextEmbedderCreationConfig::operator *() const {
  auto swig_cres = inworld_optional_TextEmbedderCreationConfig_getConst(swig_self());
  return TextEmbedderCreationConfig{swig_cres, false};
}
inline TextEmbedderCreationConfig optional_TextEmbedderCreationConfig::get_value() {
  auto swig_cres = inworld_optional_TextEmbedderCreationConfig_get_value(swig_self());
  return TextEmbedderCreationConfig{swig_cres, false};
}
inline void optional_TextEmbedderCreationConfig::set_value(TextEmbedderCreationConfig & t) { inworld_optional_TextEmbedderCreationConfig_set_value(swig_self(), t.swig_self()); }
inline optional_LLMCreationConfig::optional_LLMCreationConfig() : optional_LLMCreationConfig{inworld_optional_LLMCreationConfig_new()} {}
inline optional_LLMCreationConfig::optional_LLMCreationConfig(LLMCreationConfig const & value) : optional_LLMCreationConfig{inworld_optional_LLMCreationConfig_new_rcinworld_LLMCreationConfig(value.swig_self())} {}
inline optional_LLMCreationConfig::optional_LLMCreationConfig(optional_LLMCreationConfig const & other) : optional_LLMCreationConfig{inworld_optional_LLMCreationConfig_copy(other.swig_self())} {}
inline bool optional_LLMCreationConfig::has_value() const { return inworld_optional_LLMCreationConfig_has_value(swig_self()); }
inline LLMCreationConfig optional_LLMCreationConfig::value() {
  auto swig_cres = inworld_optional_LLMCreationConfig_value(swig_self());
  return LLMCreationConfig{swig_cres, false};
}
inline LLMCreationConfig optional_LLMCreationConfig::value() const {
  auto swig_cres = inworld_optional_LLMCreationConfig_valueConst(swig_self());
  return LLMCreationConfig{swig_cres, false};
}
inline LLMCreationConfig optional_LLMCreationConfig::value_or(LLMCreationConfig const & default_value) const {
  auto swig_cres = inworld_optional_LLMCreationConfig_value_or(swig_self(), default_value.swig_self());
  return LLMCreationConfig{swig_cres, true};
}
inline void optional_LLMCreationConfig::reset() { inworld_optional_LLMCreationConfig_reset(swig_self()); }
inline LLMCreationConfig optional_LLMCreationConfig::operator *() {
  auto swig_cres = inworld_optional_LLMCreationConfig_get(swig_self());
  return LLMCreationConfig{swig_cres, false};
}
inline LLMCreationConfig optional_LLMCreationConfig::operator *() const {
  auto swig_cres = inworld_optional_LLMCreationConfig_getConst(swig_self());
  return LLMCreationConfig{swig_cres, false};
}
inline LLMCreationConfig optional_LLMCreationConfig::get_value() {
  auto swig_cres = inworld_optional_LLMCreationConfig_get_value(swig_self());
  return LLMCreationConfig{swig_cres, false};
}
inline void optional_LLMCreationConfig::set_value(LLMCreationConfig & t) { inworld_optional_LLMCreationConfig_set_value(swig_self(), t.swig_self()); }
inline void IntentNodeExecutionConfig::matcher_config(IntentMatcherConfig * matcher_config) { inworld_IntentNodeExecutionConfig_matcher_config_set(swig_self(), matcher_config->swig_self()); }
inline IntentMatcherConfig * IntentNodeExecutionConfig::matcher_config() const {
  auto swig_cres = inworld_IntentNodeExecutionConfig_matcher_config_get(swig_self());
  return swig_cres ? new IntentMatcherConfig(swig_cres, false) : nullptr;
}
inline bool IntentNodeExecutionConfig::is_valid() const { return inworld_IntentNodeExecutionConfig_is_valid(swig_self()); }
inline IntentNodeExecutionConfig::IntentNodeExecutionConfig() : IntentNodeExecutionConfig{inworld_IntentNodeExecutionConfig_new()} {}
inline IntentNodeExecutionConfig::IntentNodeExecutionConfig(IntentNodeExecutionConfig const & other) : IntentNodeExecutionConfig{inworld_IntentNodeExecutionConfig_copy(other.swig_self())} {}
inline void IntentNodeCreationConfig::intents(vector_Intent * intents) { inworld_IntentNodeCreationConfig_intents_set(swig_self(), intents->swig_self()); }
inline vector_Intent * IntentNodeCreationConfig::intents() const {
  auto swig_cres = inworld_IntentNodeCreationConfig_intents_get(swig_self());
  return swig_cres ? new vector_Intent(swig_cres, false) : nullptr;
}
inline void IntentNodeCreationConfig::embedder_component_id(optional_string * embedder_component_id) { inworld_IntentNodeCreationConfig_embedder_component_id_set(swig_self(), embedder_component_id->swig_self()); }
inline optional_string * IntentNodeCreationConfig::embedder_component_id() const {
  auto swig_cres = inworld_IntentNodeCreationConfig_embedder_component_id_get(swig_self());
  return swig_cres ? new optional_string(swig_cres, false) : nullptr;
}
inline void IntentNodeCreationConfig::llm_component_id(optional_string * llm_component_id) { inworld_IntentNodeCreationConfig_llm_component_id_set(swig_self(), llm_component_id->swig_self()); }
inline optional_string * IntentNodeCreationConfig::llm_component_id() const {
  auto swig_cres = inworld_IntentNodeCreationConfig_llm_component_id_get(swig_self());
  return swig_cres ? new optional_string(swig_cres, false) : nullptr;
}
inline IntentNodeCreationConfig::IntentNodeCreationConfig() : IntentNodeCreationConfig{inworld_IntentNodeCreationConfig_new()} {}
inline IntentNodeCreationConfig::IntentNodeCreationConfig(IntentNodeCreationConfig const & other) : IntentNodeCreationConfig{inworld_IntentNodeCreationConfig_copy(other.swig_self())} {}
inline bool IntentNode::is_valid() const { return inworld_IntentNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_IntentNode IntentNode::inworld_inworld_graphs_IntentNode_Create__SWIG(std::string const& id, CreationContext const & arg2, IntentNodeCreationConfig const & arg3, IntentNodeExecutionConfig const& arg4) {
  auto swig_cres = inworld_IntentNode_Create((&id)->c_str(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_SharedPtr_IntentNode{swig_cres, true};
}
inline StatusOr_SharedPtr_KeywordMatcherNode::StatusOr_SharedPtr_KeywordMatcherNode() : StatusOr_SharedPtr_KeywordMatcherNode{inworld_StatusOr_SharedPtr_KeywordMatcherNode_new()} {}
inline StatusOr_SharedPtr_KeywordMatcherNode::StatusOr_SharedPtr_KeywordMatcherNode(KeywordMatcherNode const& value) : StatusOr_SharedPtr_KeywordMatcherNode{inworld_StatusOr_SharedPtr_KeywordMatcherNode_new_rcstd_shared_ptr_Sl_inworld_graphs_KeywordMatcherNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_KeywordMatcherNode::StatusOr_SharedPtr_KeywordMatcherNode(Status const & status) : StatusOr_SharedPtr_KeywordMatcherNode{inworld_StatusOr_SharedPtr_KeywordMatcherNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_KeywordMatcherNode::ok() const { return inworld_StatusOr_SharedPtr_KeywordMatcherNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_KeywordMatcherNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_KeywordMatcherNode_status(swig_self());
  return Status{swig_cres, false};
}
inline KeywordMatcherNode StatusOr_SharedPtr_KeywordMatcherNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_KeywordMatcherNode_value(swig_self());
  return KeywordMatcherNode{swig_cres, true};
}
inline StatusOr_SharedPtr_KeywordMatcherNode::StatusOr_SharedPtr_KeywordMatcherNode(StatusOr_SharedPtr_KeywordMatcherNode const & other) : StatusOr_SharedPtr_KeywordMatcherNode{inworld_StatusOr_SharedPtr_KeywordMatcherNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_MatchedKeywords::StatusOr_SharedPtr_MatchedKeywords() : StatusOr_SharedPtr_MatchedKeywords{inworld_StatusOr_SharedPtr_MatchedKeywords_new()} {}
inline StatusOr_SharedPtr_MatchedKeywords::StatusOr_SharedPtr_MatchedKeywords(MatchedKeywords const& value) : StatusOr_SharedPtr_MatchedKeywords{inworld_StatusOr_SharedPtr_MatchedKeywords_new_rcstd_shared_ptr_Sl_inworld_graphs_MatchedKeywords_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_MatchedKeywords::StatusOr_SharedPtr_MatchedKeywords(Status const & status) : StatusOr_SharedPtr_MatchedKeywords{inworld_StatusOr_SharedPtr_MatchedKeywords_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_MatchedKeywords::ok() const { return inworld_StatusOr_SharedPtr_MatchedKeywords_ok(swig_self()); }
inline Status StatusOr_SharedPtr_MatchedKeywords::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MatchedKeywords_status(swig_self());
  return Status{swig_cres, false};
}
inline MatchedKeywords StatusOr_SharedPtr_MatchedKeywords::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MatchedKeywords_value(swig_self());
  return MatchedKeywords{swig_cres, true};
}
inline StatusOr_SharedPtr_MatchedKeywords::StatusOr_SharedPtr_MatchedKeywords(StatusOr_SharedPtr_MatchedKeywords const & other) : StatusOr_SharedPtr_MatchedKeywords{inworld_StatusOr_SharedPtr_MatchedKeywords_copy(other.swig_self())} {}
inline void KeywordMatcherNodeCreationConfig::keyword_groups(vector_KeywordGroup * keyword_groups) { inworld_KeywordMatcherNodeCreationConfig_keyword_groups_set(swig_self(), keyword_groups->swig_self()); }
inline vector_KeywordGroup * KeywordMatcherNodeCreationConfig::keyword_groups() const {
  auto swig_cres = inworld_KeywordMatcherNodeCreationConfig_keyword_groups_get(swig_self());
  return swig_cres ? new vector_KeywordGroup(swig_cres, false) : nullptr;
}
inline KeywordMatcherNodeCreationConfig::KeywordMatcherNodeCreationConfig() : KeywordMatcherNodeCreationConfig{inworld_KeywordMatcherNodeCreationConfig_new()} {}
inline KeywordMatcherNodeCreationConfig::KeywordMatcherNodeCreationConfig(KeywordMatcherNodeCreationConfig const & other) : KeywordMatcherNodeCreationConfig{inworld_KeywordMatcherNodeCreationConfig_copy(other.swig_self())} {}
inline bool KeywordMatcherNode::is_valid() const { return inworld_KeywordMatcherNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_KeywordMatcherNode KeywordMatcherNode::inworld_inworld_graphs_KeywordMatcherNode_Create__SWIG_0(std::string const& id, KeywordMatcherNodeCreationConfig const & arg2) {
  auto swig_cres = inworld_KeywordMatcherNode_Create_rcstd_string_rcinworld_graphs_KeywordMatcherNodeCreationConfig((&id)->c_str(), arg2.swig_self());
  return StatusOr_SharedPtr_KeywordMatcherNode{swig_cres, true};
}
inline StatusOr_SharedPtr_KeywordMatcherNode KeywordMatcherNode::inworld_inworld_graphs_KeywordMatcherNode_Create__SWIG_1(std::string const& id, KeywordMatcherNodeCreationConfig const & arg2, NodeExecutionConfig const& arg3) {
  auto swig_cres = inworld_KeywordMatcherNode_Create_rcstd_string_rcinworld_graphs_KeywordMatcherNodeCreationConfig_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg_((&id)->c_str(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_SharedPtr_KeywordMatcherNode{swig_cres, true};
}
inline KeywordMatcherNode::KeywordMatcherNode(KeywordMatcherNode const & other) : KeywordMatcherNode{inworld_KeywordMatcherNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_KnowledgeNode::StatusOr_SharedPtr_KnowledgeNode() : StatusOr_SharedPtr_KnowledgeNode{inworld_StatusOr_SharedPtr_KnowledgeNode_new()} {}
inline StatusOr_SharedPtr_KnowledgeNode::StatusOr_SharedPtr_KnowledgeNode(KnowledgeNode const& value) : StatusOr_SharedPtr_KnowledgeNode{inworld_StatusOr_SharedPtr_KnowledgeNode_new_rcstd_shared_ptr_Sl_inworld_graphs_KnowledgeNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_KnowledgeNode::StatusOr_SharedPtr_KnowledgeNode(Status const & status) : StatusOr_SharedPtr_KnowledgeNode{inworld_StatusOr_SharedPtr_KnowledgeNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_KnowledgeNode::ok() const { return inworld_StatusOr_SharedPtr_KnowledgeNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_KnowledgeNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_KnowledgeNode_status(swig_self());
  return Status{swig_cres, false};
}
inline KnowledgeNode StatusOr_SharedPtr_KnowledgeNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_KnowledgeNode_value(swig_self());
  return KnowledgeNode{swig_cres, true};
}
inline StatusOr_SharedPtr_KnowledgeNode::StatusOr_SharedPtr_KnowledgeNode(StatusOr_SharedPtr_KnowledgeNode const & other) : StatusOr_SharedPtr_KnowledgeNode{inworld_StatusOr_SharedPtr_KnowledgeNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_KnowledgeRecords::StatusOr_SharedPtr_KnowledgeRecords() : StatusOr_SharedPtr_KnowledgeRecords{inworld_StatusOr_SharedPtr_KnowledgeRecords_new()} {}
inline StatusOr_SharedPtr_KnowledgeRecords::StatusOr_SharedPtr_KnowledgeRecords(KnowledgeRecords const& value) : StatusOr_SharedPtr_KnowledgeRecords{inworld_StatusOr_SharedPtr_KnowledgeRecords_new_rcstd_shared_ptr_Sl_inworld_graphs_KnowledgeRecords_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_KnowledgeRecords::StatusOr_SharedPtr_KnowledgeRecords(Status const & status) : StatusOr_SharedPtr_KnowledgeRecords{inworld_StatusOr_SharedPtr_KnowledgeRecords_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_KnowledgeRecords::ok() const { return inworld_StatusOr_SharedPtr_KnowledgeRecords_ok(swig_self()); }
inline Status StatusOr_SharedPtr_KnowledgeRecords::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_KnowledgeRecords_status(swig_self());
  return Status{swig_cres, false};
}
inline KnowledgeRecords StatusOr_SharedPtr_KnowledgeRecords::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_KnowledgeRecords_value(swig_self());
  return KnowledgeRecords{swig_cres, true};
}
inline StatusOr_SharedPtr_KnowledgeRecords::StatusOr_SharedPtr_KnowledgeRecords(StatusOr_SharedPtr_KnowledgeRecords const & other) : StatusOr_SharedPtr_KnowledgeRecords{inworld_StatusOr_SharedPtr_KnowledgeRecords_copy(other.swig_self())} {}
inline void KnowledgeNodeCreationConfig::knowledge_id(std::string const& knowledge_id) { inworld_KnowledgeNodeCreationConfig_knowledge_id_set(swig_self(), (&knowledge_id)->c_str()); }
inline std::string KnowledgeNodeCreationConfig::knowledge_id() const {
  auto swig_cres = inworld_KnowledgeNodeCreationConfig_knowledge_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void KnowledgeNodeCreationConfig::knowledge_records(vector_string * knowledge_records) { inworld_KnowledgeNodeCreationConfig_knowledge_records_set(swig_self(), knowledge_records->swig_self()); }
inline vector_string * KnowledgeNodeCreationConfig::knowledge_records() const {
  auto swig_cres = inworld_KnowledgeNodeCreationConfig_knowledge_records_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline void KnowledgeNodeCreationConfig::knowledge_component_id(std::string const& knowledge_component_id) { inworld_KnowledgeNodeCreationConfig_knowledge_component_id_set(swig_self(), (&knowledge_component_id)->c_str()); }
inline std::string KnowledgeNodeCreationConfig::knowledge_component_id() const {
  auto swig_cres = inworld_KnowledgeNodeCreationConfig_knowledge_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline KnowledgeNodeCreationConfig::KnowledgeNodeCreationConfig() : KnowledgeNodeCreationConfig{inworld_KnowledgeNodeCreationConfig_new()} {}
inline KnowledgeNodeCreationConfig::KnowledgeNodeCreationConfig(KnowledgeNodeCreationConfig const & other) : KnowledgeNodeCreationConfig{inworld_KnowledgeNodeCreationConfig_copy(other.swig_self())} {}
inline void KnowledgeNodeExecutionConfig::knowledge_ids(vector_string * knowledge_ids) { inworld_KnowledgeNodeExecutionConfig_knowledge_ids_set(swig_self(), knowledge_ids->swig_self()); }
inline vector_string * KnowledgeNodeExecutionConfig::knowledge_ids() const {
  auto swig_cres = inworld_KnowledgeNodeExecutionConfig_knowledge_ids_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline void KnowledgeNodeExecutionConfig::retrieval_config(RetrievalConfig * retrieval_config) { inworld_KnowledgeNodeExecutionConfig_retrieval_config_set(swig_self(), retrieval_config->swig_self()); }
inline RetrievalConfig * KnowledgeNodeExecutionConfig::retrieval_config() const {
  auto swig_cres = inworld_KnowledgeNodeExecutionConfig_retrieval_config_get(swig_self());
  return swig_cres ? new RetrievalConfig(swig_cres, false) : nullptr;
}
inline bool KnowledgeNodeExecutionConfig::is_valid() const { return inworld_KnowledgeNodeExecutionConfig_is_valid(swig_self()); }
inline KnowledgeNodeExecutionConfig::KnowledgeNodeExecutionConfig() : KnowledgeNodeExecutionConfig{inworld_KnowledgeNodeExecutionConfig_new()} {}
inline KnowledgeNodeExecutionConfig::KnowledgeNodeExecutionConfig(KnowledgeNodeExecutionConfig const & other) : KnowledgeNodeExecutionConfig{inworld_KnowledgeNodeExecutionConfig_copy(other.swig_self())} {}
inline bool KnowledgeNode::is_valid() const { return inworld_KnowledgeNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_KnowledgeNode KnowledgeNode::inworld_inworld_graphs_KnowledgeNode_Create__SWIG(std::string const& id, CreationContext const & arg2, KnowledgeNodeCreationConfig const & arg3, KnowledgeNodeExecutionConfig const& arg4) {
  auto swig_cres = inworld_KnowledgeNode_Create((&id)->c_str(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_SharedPtr_KnowledgeNode{swig_cres, true};
}
inline KnowledgeNode::KnowledgeNode(KnowledgeNode const & other) : KnowledgeNode{inworld_KnowledgeNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_LLMChatNode::StatusOr_SharedPtr_LLMChatNode() : StatusOr_SharedPtr_LLMChatNode{inworld_StatusOr_SharedPtr_LLMChatNode_new()} {}
inline StatusOr_SharedPtr_LLMChatNode::StatusOr_SharedPtr_LLMChatNode(LLMChatNode const& value) : StatusOr_SharedPtr_LLMChatNode{inworld_StatusOr_SharedPtr_LLMChatNode_new_rcstd_shared_ptr_Sl_inworld_graphs_LLMChatNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_LLMChatNode::StatusOr_SharedPtr_LLMChatNode(Status const & status) : StatusOr_SharedPtr_LLMChatNode{inworld_StatusOr_SharedPtr_LLMChatNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_LLMChatNode::ok() const { return inworld_StatusOr_SharedPtr_LLMChatNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_LLMChatNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_LLMChatNode_status(swig_self());
  return Status{swig_cres, false};
}
inline LLMChatNode StatusOr_SharedPtr_LLMChatNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_LLMChatNode_value(swig_self());
  return LLMChatNode{swig_cres, true};
}
inline StatusOr_SharedPtr_LLMChatNode::StatusOr_SharedPtr_LLMChatNode(StatusOr_SharedPtr_LLMChatNode const & other) : StatusOr_SharedPtr_LLMChatNode{inworld_StatusOr_SharedPtr_LLMChatNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_LLMChatResponse::StatusOr_SharedPtr_LLMChatResponse() : StatusOr_SharedPtr_LLMChatResponse{inworld_StatusOr_SharedPtr_LLMChatResponse_new()} {}
inline StatusOr_SharedPtr_LLMChatResponse::StatusOr_SharedPtr_LLMChatResponse(LLMChatResponse const& value) : StatusOr_SharedPtr_LLMChatResponse{inworld_StatusOr_SharedPtr_LLMChatResponse_new_rcstd_shared_ptr_Sl_inworld_graphs_LLMChatResponse_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_LLMChatResponse::StatusOr_SharedPtr_LLMChatResponse(Status const & status) : StatusOr_SharedPtr_LLMChatResponse{inworld_StatusOr_SharedPtr_LLMChatResponse_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_LLMChatResponse::ok() const { return inworld_StatusOr_SharedPtr_LLMChatResponse_ok(swig_self()); }
inline Status StatusOr_SharedPtr_LLMChatResponse::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_LLMChatResponse_status(swig_self());
  return Status{swig_cres, false};
}
inline LLMChatResponse StatusOr_SharedPtr_LLMChatResponse::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_LLMChatResponse_value(swig_self());
  return LLMChatResponse{swig_cres, true};
}
inline StatusOr_SharedPtr_LLMChatResponse::StatusOr_SharedPtr_LLMChatResponse(StatusOr_SharedPtr_LLMChatResponse const & other) : StatusOr_SharedPtr_LLMChatResponse{inworld_StatusOr_SharedPtr_LLMChatResponse_copy(other.swig_self())} {}
inline optional_vector_LLMRoutingConfig::optional_vector_LLMRoutingConfig() : optional_vector_LLMRoutingConfig{inworld_optional_vector_LLMRoutingConfig_new()} {}
inline optional_vector_LLMRoutingConfig::optional_vector_LLMRoutingConfig(vector_LLMRoutingConfig const & value) : optional_vector_LLMRoutingConfig{inworld_optional_vector_LLMRoutingConfig_new_rcstd_vector_Sl_inworld_LLMRoutingConfig_Sg_(value.swig_self())} {}
inline optional_vector_LLMRoutingConfig::optional_vector_LLMRoutingConfig(optional_vector_LLMRoutingConfig const & other) : optional_vector_LLMRoutingConfig{inworld_optional_vector_LLMRoutingConfig_copy(other.swig_self())} {}
inline bool optional_vector_LLMRoutingConfig::has_value() const { return inworld_optional_vector_LLMRoutingConfig_has_value(swig_self()); }
inline vector_LLMRoutingConfig optional_vector_LLMRoutingConfig::value() {
  auto swig_cres = inworld_optional_vector_LLMRoutingConfig_value(swig_self());
  return vector_LLMRoutingConfig{swig_cres, false};
}
inline vector_LLMRoutingConfig optional_vector_LLMRoutingConfig::value() const {
  auto swig_cres = inworld_optional_vector_LLMRoutingConfig_valueConst(swig_self());
  return vector_LLMRoutingConfig{swig_cres, false};
}
inline vector_LLMRoutingConfig optional_vector_LLMRoutingConfig::value_or(vector_LLMRoutingConfig const & default_value) const {
  auto swig_cres = inworld_optional_vector_LLMRoutingConfig_value_or(swig_self(), default_value.swig_self());
  return vector_LLMRoutingConfig{swig_cres, true};
}
inline void optional_vector_LLMRoutingConfig::reset() { inworld_optional_vector_LLMRoutingConfig_reset(swig_self()); }
inline vector_LLMRoutingConfig optional_vector_LLMRoutingConfig::operator *() {
  auto swig_cres = inworld_optional_vector_LLMRoutingConfig_get(swig_self());
  return vector_LLMRoutingConfig{swig_cres, false};
}
inline vector_LLMRoutingConfig optional_vector_LLMRoutingConfig::operator *() const {
  auto swig_cres = inworld_optional_vector_LLMRoutingConfig_getConst(swig_self());
  return vector_LLMRoutingConfig{swig_cres, false};
}
inline vector_LLMRoutingConfig optional_vector_LLMRoutingConfig::get_value() {
  auto swig_cres = inworld_optional_vector_LLMRoutingConfig_get_value(swig_self());
  return vector_LLMRoutingConfig{swig_cres, false};
}
inline void optional_vector_LLMRoutingConfig::set_value(vector_LLMRoutingConfig & t) { inworld_optional_vector_LLMRoutingConfig_set_value(swig_self(), t.swig_self()); }
inline void StringTemplate::value(std::string const& value) { inworld_StringTemplate_value_set(swig_self(), (&value)->c_str()); }
inline std::string StringTemplate::value() const {
  auto swig_cres = inworld_StringTemplate_value_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline StringTemplate::StringTemplate() : StringTemplate{inworld_StringTemplate_new()} {}
inline StringTemplate::StringTemplate(StringTemplate const & other) : StringTemplate{inworld_StringTemplate_copy(other.swig_self())} {}
inline TextContent::TextContent() : TextContent{inworld_TextContent_new()} {}
inline TextContent::TextContent(TextContent const & other) : TextContent{inworld_TextContent_copy(other.swig_self())} {}
inline void ImageContent::detail(std::string const& detail) { inworld_ImageContent_detail_set(swig_self(), (&detail)->c_str()); }
inline std::string ImageContent::detail() const {
  auto swig_cres = inworld_ImageContent_detail_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline ImageContent::ImageContent() : ImageContent{inworld_ImageContent_new()} {}
inline ImageContent::ImageContent(ImageContent const & other) : ImageContent{inworld_ImageContent_copy(other.swig_self())} {}
inline ChatMessageContent::ChatMessageContent() : ChatMessageContent{inworld_ChatMessageContent_new()} {}
inline ChatMessageContent::ChatMessageContent(ChatMessageContent const & other) : ChatMessageContent{inworld_ChatMessageContent_copy(other.swig_self())} {}
inline void ChatMessage::role(std::string const& role) { inworld_ChatMessage_role_set(swig_self(), (&role)->c_str()); }
inline std::string ChatMessage::role() const {
  auto swig_cres = inworld_ChatMessage_role_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline bool ChatMessage::HasSingleContent() const { return inworld_ChatMessage_HasSingleContent(swig_self()); }
inline bool ChatMessage::HasMultimodalContent() const { return inworld_ChatMessage_HasMultimodalContent(swig_self()); }
inline void ChatMessage::SetTextContent(std::string const& text) { inworld_ChatMessage_SetTextContent(swig_self(), (&text)->c_str()); }
inline void ChatMessage::SetTemplateContent(std::string const& template_str) { inworld_ChatMessage_SetTemplateContent(swig_self(), (&template_str)->c_str()); }
inline void ChatMessage::InitMultimodalContent() { inworld_ChatMessage_InitMultimodalContent(swig_self()); }
inline void ChatMessage::AddTextToMultimodal(std::string const& text) { inworld_ChatMessage_AddTextToMultimodal(swig_self(), (&text)->c_str()); }
inline void ChatMessage::AddTemplateToMultimodal(std::string const& template_str) { inworld_ChatMessage_AddTemplateToMultimodal(swig_self(), (&template_str)->c_str()); }
inline void ChatMessage::AddImageToMultimodal(std::string const& url, std::string const& arg3) { inworld_ChatMessage_AddImageToMultimodal_rcstd_string_rcstd_string(swig_self(), (&url)->c_str(), (&arg3)->c_str()); }
inline void ChatMessage::AddImageToMultimodal(std::string const& url) { inworld_ChatMessage_AddImageToMultimodal_rcstd_string(swig_self(), (&url)->c_str()); }
inline void ChatMessage::AddImageTemplateToMultimodal(std::string const& url_template, std::string const& arg3) { inworld_ChatMessage_AddImageTemplateToMultimodal_rcstd_string_rcstd_string(swig_self(), (&url_template)->c_str(), (&arg3)->c_str()); }
inline void ChatMessage::AddImageTemplateToMultimodal(std::string const& url_template) { inworld_ChatMessage_AddImageTemplateToMultimodal_rcstd_string(swig_self(), (&url_template)->c_str()); }
inline int ChatMessage::GetMultimodalItemCount() const { return inworld_ChatMessage_GetMultimodalItemCount(swig_self()); }
inline ChatMessage::ChatMessage() : ChatMessage{inworld_ChatMessage_new()} {}
inline ChatMessage::ChatMessage(ChatMessage const & other) : ChatMessage{inworld_ChatMessage_copy(other.swig_self())} {}
inline void LLMChatNodeExecutionConfig::llm_component_id(std::string const& llm_component_id) { inworld_LLMChatNodeExecutionConfig_llm_component_id_set(swig_self(), (&llm_component_id)->c_str()); }
inline std::string LLMChatNodeExecutionConfig::llm_component_id() const {
  auto swig_cres = inworld_LLMChatNodeExecutionConfig_llm_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LLMChatNodeExecutionConfig::text_generation_config(optional_TextGenerationConfig * text_generation_config) { inworld_LLMChatNodeExecutionConfig_text_generation_config_set(swig_self(), text_generation_config->swig_self()); }
inline optional_TextGenerationConfig * LLMChatNodeExecutionConfig::text_generation_config() const {
  auto swig_cres = inworld_LLMChatNodeExecutionConfig_text_generation_config_get(swig_self());
  return swig_cres ? new optional_TextGenerationConfig(swig_cres, false) : nullptr;
}
inline void LLMChatNodeExecutionConfig::message_templates(optional_vector_ChatMessage * message_templates) { inworld_LLMChatNodeExecutionConfig_message_templates_set(swig_self(), message_templates->swig_self()); }
inline optional_vector_ChatMessage * LLMChatNodeExecutionConfig::message_templates() const {
  auto swig_cres = inworld_LLMChatNodeExecutionConfig_message_templates_get(swig_self());
  return swig_cres ? new optional_vector_ChatMessage(swig_cres, false) : nullptr;
}
inline void LLMChatNodeExecutionConfig::tools(optional_vector_Tool * tools) { inworld_LLMChatNodeExecutionConfig_tools_set(swig_self(), tools->swig_self()); }
inline optional_vector_Tool * LLMChatNodeExecutionConfig::tools() const {
  auto swig_cres = inworld_LLMChatNodeExecutionConfig_tools_get(swig_self());
  return swig_cres ? new optional_vector_Tool(swig_cres, false) : nullptr;
}
inline void LLMChatNodeExecutionConfig::tool_choice(optional_ToolChoice * tool_choice) { inworld_LLMChatNodeExecutionConfig_tool_choice_set(swig_self(), tool_choice->swig_self()); }
inline optional_ToolChoice * LLMChatNodeExecutionConfig::tool_choice() const {
  auto swig_cres = inworld_LLMChatNodeExecutionConfig_tool_choice_get(swig_self());
  return swig_cres ? new optional_ToolChoice(swig_cres, false) : nullptr;
}
inline void LLMChatNodeExecutionConfig::stream(bool stream) { inworld_LLMChatNodeExecutionConfig_stream_set(swig_self(), stream); }
inline bool LLMChatNodeExecutionConfig::stream() const { return inworld_LLMChatNodeExecutionConfig_stream_get(swig_self()); }
inline void LLMChatNodeExecutionConfig::response_format(ResponseFormat response_format) { inworld_LLMChatNodeExecutionConfig_response_format_set(swig_self(), (inworld_ResponseFormat)response_format); }
inline ResponseFormat LLMChatNodeExecutionConfig::response_format() const {
  auto swig_cres = inworld_LLMChatNodeExecutionConfig_response_format_get(swig_self());
  return (ResponseFormat)swig_cres;
}
inline bool LLMChatNodeExecutionConfig::is_valid() const { return inworld_LLMChatNodeExecutionConfig_is_valid(swig_self()); }
inline LLMChatNodeExecutionConfig::LLMChatNodeExecutionConfig() : LLMChatNodeExecutionConfig{inworld_LLMChatNodeExecutionConfig_new()} {}
inline LLMChatNodeExecutionConfig::LLMChatNodeExecutionConfig(LLMChatNodeExecutionConfig const & other) : LLMChatNodeExecutionConfig{inworld_LLMChatNodeExecutionConfig_copy(other.swig_self())} {}
inline bool LLMChatNode::is_valid() const { return inworld_LLMChatNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_LLMChatNode LLMChatNode::inworld_inworld_graphs_LLMChatNode_Create__SWIG(std::string const& id, LLMChatNodeExecutionConfig const& arg2) {
  auto swig_cres = inworld_LLMChatNode_Create((&id)->c_str(), arg2.swig_self());
  return StatusOr_SharedPtr_LLMChatNode{swig_cres, true};
}
inline StatusOr_SharedPtr_LLMCompletionNode::StatusOr_SharedPtr_LLMCompletionNode() : StatusOr_SharedPtr_LLMCompletionNode{inworld_StatusOr_SharedPtr_LLMCompletionNode_new()} {}
inline StatusOr_SharedPtr_LLMCompletionNode::StatusOr_SharedPtr_LLMCompletionNode(LLMCompletionNode const& value) : StatusOr_SharedPtr_LLMCompletionNode{inworld_StatusOr_SharedPtr_LLMCompletionNode_new_rcstd_shared_ptr_Sl_inworld_graphs_LLMCompletionNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_LLMCompletionNode::StatusOr_SharedPtr_LLMCompletionNode(Status const & status) : StatusOr_SharedPtr_LLMCompletionNode{inworld_StatusOr_SharedPtr_LLMCompletionNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_LLMCompletionNode::ok() const { return inworld_StatusOr_SharedPtr_LLMCompletionNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_LLMCompletionNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_LLMCompletionNode_status(swig_self());
  return Status{swig_cres, false};
}
inline LLMCompletionNode StatusOr_SharedPtr_LLMCompletionNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_LLMCompletionNode_value(swig_self());
  return LLMCompletionNode{swig_cres, true};
}
inline StatusOr_SharedPtr_LLMCompletionNode::StatusOr_SharedPtr_LLMCompletionNode(StatusOr_SharedPtr_LLMCompletionNode const & other) : StatusOr_SharedPtr_LLMCompletionNode{inworld_StatusOr_SharedPtr_LLMCompletionNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_LLMCompletionResponse::StatusOr_SharedPtr_LLMCompletionResponse() : StatusOr_SharedPtr_LLMCompletionResponse{inworld_StatusOr_SharedPtr_LLMCompletionResponse_new()} {}
inline StatusOr_SharedPtr_LLMCompletionResponse::StatusOr_SharedPtr_LLMCompletionResponse(LLMCompletionResponse const& value) : StatusOr_SharedPtr_LLMCompletionResponse{inworld_StatusOr_SharedPtr_LLMCompletionResponse_new_rcstd_shared_ptr_Sl_inworld_graphs_LLMCompletionResponse_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_LLMCompletionResponse::StatusOr_SharedPtr_LLMCompletionResponse(Status const & status) : StatusOr_SharedPtr_LLMCompletionResponse{inworld_StatusOr_SharedPtr_LLMCompletionResponse_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_LLMCompletionResponse::ok() const { return inworld_StatusOr_SharedPtr_LLMCompletionResponse_ok(swig_self()); }
inline Status StatusOr_SharedPtr_LLMCompletionResponse::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_LLMCompletionResponse_status(swig_self());
  return Status{swig_cres, false};
}
inline LLMCompletionResponse StatusOr_SharedPtr_LLMCompletionResponse::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_LLMCompletionResponse_value(swig_self());
  return LLMCompletionResponse{swig_cres, true};
}
inline StatusOr_SharedPtr_LLMCompletionResponse::StatusOr_SharedPtr_LLMCompletionResponse(StatusOr_SharedPtr_LLMCompletionResponse const & other) : StatusOr_SharedPtr_LLMCompletionResponse{inworld_StatusOr_SharedPtr_LLMCompletionResponse_copy(other.swig_self())} {}
inline void LLMCompletionNodeExecutionConfig::llm_component_id(std::string const& llm_component_id) { inworld_LLMCompletionNodeExecutionConfig_llm_component_id_set(swig_self(), (&llm_component_id)->c_str()); }
inline std::string LLMCompletionNodeExecutionConfig::llm_component_id() const {
  auto swig_cres = inworld_LLMCompletionNodeExecutionConfig_llm_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void LLMCompletionNodeExecutionConfig::text_generation_config(optional_TextGenerationConfig * text_generation_config) { inworld_LLMCompletionNodeExecutionConfig_text_generation_config_set(swig_self(), text_generation_config->swig_self()); }
inline optional_TextGenerationConfig * LLMCompletionNodeExecutionConfig::text_generation_config() const {
  auto swig_cres = inworld_LLMCompletionNodeExecutionConfig_text_generation_config_get(swig_self());
  return swig_cres ? new optional_TextGenerationConfig(swig_cres, false) : nullptr;
}
inline void LLMCompletionNodeExecutionConfig::stream(bool stream) { inworld_LLMCompletionNodeExecutionConfig_stream_set(swig_self(), stream); }
inline bool LLMCompletionNodeExecutionConfig::stream() const { return inworld_LLMCompletionNodeExecutionConfig_stream_get(swig_self()); }
inline void LLMCompletionNodeExecutionConfig::prompt_template(optional_string * prompt_template) { inworld_LLMCompletionNodeExecutionConfig_prompt_template_set(swig_self(), prompt_template->swig_self()); }
inline optional_string * LLMCompletionNodeExecutionConfig::prompt_template() const {
  auto swig_cres = inworld_LLMCompletionNodeExecutionConfig_prompt_template_get(swig_self());
  return swig_cres ? new optional_string(swig_cres, false) : nullptr;
}
inline bool LLMCompletionNodeExecutionConfig::is_valid() const { return inworld_LLMCompletionNodeExecutionConfig_is_valid(swig_self()); }
inline LLMCompletionNodeExecutionConfig::LLMCompletionNodeExecutionConfig() : LLMCompletionNodeExecutionConfig{inworld_LLMCompletionNodeExecutionConfig_new()} {}
inline LLMCompletionNodeExecutionConfig::LLMCompletionNodeExecutionConfig(LLMCompletionNodeExecutionConfig const & other) : LLMCompletionNodeExecutionConfig{inworld_LLMCompletionNodeExecutionConfig_copy(other.swig_self())} {}
inline bool LLMCompletionNode::is_valid() const { return inworld_LLMCompletionNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_LLMCompletionNode LLMCompletionNode::inworld_inworld_graphs_LLMCompletionNode_Create__SWIG(std::string const& id, LLMCompletionNodeExecutionConfig const& arg2) {
  auto swig_cres = inworld_LLMCompletionNode_Create((&id)->c_str(), arg2.swig_self());
  return StatusOr_SharedPtr_LLMCompletionNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MCPListToolsNode::StatusOr_SharedPtr_MCPListToolsNode() : StatusOr_SharedPtr_MCPListToolsNode{inworld_StatusOr_SharedPtr_MCPListToolsNode_new()} {}
inline StatusOr_SharedPtr_MCPListToolsNode::StatusOr_SharedPtr_MCPListToolsNode(MCPListToolsNode const& value) : StatusOr_SharedPtr_MCPListToolsNode{inworld_StatusOr_SharedPtr_MCPListToolsNode_new_rcstd_shared_ptr_Sl_inworld_graphs_MCPListToolsNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_MCPListToolsNode::StatusOr_SharedPtr_MCPListToolsNode(Status const & status) : StatusOr_SharedPtr_MCPListToolsNode{inworld_StatusOr_SharedPtr_MCPListToolsNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_MCPListToolsNode::ok() const { return inworld_StatusOr_SharedPtr_MCPListToolsNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_MCPListToolsNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MCPListToolsNode_status(swig_self());
  return Status{swig_cres, false};
}
inline MCPListToolsNode StatusOr_SharedPtr_MCPListToolsNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MCPListToolsNode_value(swig_self());
  return MCPListToolsNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MCPListToolsNode::StatusOr_SharedPtr_MCPListToolsNode(StatusOr_SharedPtr_MCPListToolsNode const & other) : StatusOr_SharedPtr_MCPListToolsNode{inworld_StatusOr_SharedPtr_MCPListToolsNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_MCPCallToolNode::StatusOr_SharedPtr_MCPCallToolNode() : StatusOr_SharedPtr_MCPCallToolNode{inworld_StatusOr_SharedPtr_MCPCallToolNode_new()} {}
inline StatusOr_SharedPtr_MCPCallToolNode::StatusOr_SharedPtr_MCPCallToolNode(MCPCallToolNode const& value) : StatusOr_SharedPtr_MCPCallToolNode{inworld_StatusOr_SharedPtr_MCPCallToolNode_new_rcstd_shared_ptr_Sl_inworld_graphs_MCPCallToolNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_MCPCallToolNode::StatusOr_SharedPtr_MCPCallToolNode(Status const & status) : StatusOr_SharedPtr_MCPCallToolNode{inworld_StatusOr_SharedPtr_MCPCallToolNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_MCPCallToolNode::ok() const { return inworld_StatusOr_SharedPtr_MCPCallToolNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_MCPCallToolNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MCPCallToolNode_status(swig_self());
  return Status{swig_cres, false};
}
inline MCPCallToolNode StatusOr_SharedPtr_MCPCallToolNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MCPCallToolNode_value(swig_self());
  return MCPCallToolNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MCPCallToolNode::StatusOr_SharedPtr_MCPCallToolNode(StatusOr_SharedPtr_MCPCallToolNode const & other) : StatusOr_SharedPtr_MCPCallToolNode{inworld_StatusOr_SharedPtr_MCPCallToolNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_ToolCallResponse::StatusOr_SharedPtr_ToolCallResponse() : StatusOr_SharedPtr_ToolCallResponse{inworld_StatusOr_SharedPtr_ToolCallResponse_new()} {}
inline StatusOr_SharedPtr_ToolCallResponse::StatusOr_SharedPtr_ToolCallResponse(ToolCallResponse const& value) : StatusOr_SharedPtr_ToolCallResponse{inworld_StatusOr_SharedPtr_ToolCallResponse_new_rcstd_shared_ptr_Sl_inworld_graphs_ToolCallResponse_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_ToolCallResponse::StatusOr_SharedPtr_ToolCallResponse(Status const & status) : StatusOr_SharedPtr_ToolCallResponse{inworld_StatusOr_SharedPtr_ToolCallResponse_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_ToolCallResponse::ok() const { return inworld_StatusOr_SharedPtr_ToolCallResponse_ok(swig_self()); }
inline Status StatusOr_SharedPtr_ToolCallResponse::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_ToolCallResponse_status(swig_self());
  return Status{swig_cres, false};
}
inline ToolCallResponse StatusOr_SharedPtr_ToolCallResponse::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_ToolCallResponse_value(swig_self());
  return ToolCallResponse{swig_cres, true};
}
inline StatusOr_SharedPtr_ToolCallResponse::StatusOr_SharedPtr_ToolCallResponse(StatusOr_SharedPtr_ToolCallResponse const & other) : StatusOr_SharedPtr_ToolCallResponse{inworld_StatusOr_SharedPtr_ToolCallResponse_copy(other.swig_self())} {}
inline void MCPListToolsNodeExecutionConfig::mcp_component_id(std::string const& mcp_component_id) { inworld_MCPListToolsNodeExecutionConfig_mcp_component_id_set(swig_self(), (&mcp_component_id)->c_str()); }
inline std::string MCPListToolsNodeExecutionConfig::mcp_component_id() const {
  auto swig_cres = inworld_MCPListToolsNodeExecutionConfig_mcp_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline bool MCPListToolsNodeExecutionConfig::is_valid() const { return inworld_MCPListToolsNodeExecutionConfig_is_valid(swig_self()); }
inline MCPListToolsNodeExecutionConfig::MCPListToolsNodeExecutionConfig() : MCPListToolsNodeExecutionConfig{inworld_MCPListToolsNodeExecutionConfig_new()} {}
inline MCPListToolsNodeExecutionConfig::MCPListToolsNodeExecutionConfig(MCPListToolsNodeExecutionConfig const & other) : MCPListToolsNodeExecutionConfig{inworld_MCPListToolsNodeExecutionConfig_copy(other.swig_self())} {}
inline bool MCPListToolsNode::is_valid() const { return inworld_MCPListToolsNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_MCPListToolsNode MCPListToolsNode::inworld_inworld_graphs_MCPListToolsNode_Create__SWIG(std::string const& id, MCPListToolsNodeExecutionConfig const& arg2) {
  auto swig_cres = inworld_MCPListToolsNode_Create((&id)->c_str(), arg2.swig_self());
  return StatusOr_SharedPtr_MCPListToolsNode{swig_cres, true};
}
inline void MCPCallToolNodeExecutionConfig::mcp_component_id(std::string const& mcp_component_id) { inworld_MCPCallToolNodeExecutionConfig_mcp_component_id_set(swig_self(), (&mcp_component_id)->c_str()); }
inline std::string MCPCallToolNodeExecutionConfig::mcp_component_id() const {
  auto swig_cres = inworld_MCPCallToolNodeExecutionConfig_mcp_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline bool MCPCallToolNodeExecutionConfig::is_valid() const { return inworld_MCPCallToolNodeExecutionConfig_is_valid(swig_self()); }
inline MCPCallToolNodeExecutionConfig::MCPCallToolNodeExecutionConfig() : MCPCallToolNodeExecutionConfig{inworld_MCPCallToolNodeExecutionConfig_new()} {}
inline MCPCallToolNodeExecutionConfig::MCPCallToolNodeExecutionConfig(MCPCallToolNodeExecutionConfig const & other) : MCPCallToolNodeExecutionConfig{inworld_MCPCallToolNodeExecutionConfig_copy(other.swig_self())} {}
inline bool MCPCallToolNode::is_valid() const { return inworld_MCPCallToolNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_MCPCallToolNode MCPCallToolNode::inworld_inworld_graphs_MCPCallToolNode_Create__SWIG(std::string const& id, MCPCallToolNodeExecutionConfig const& arg2) {
  auto swig_cres = inworld_MCPCallToolNode_Create((&id)->c_str(), arg2.swig_self());
  return StatusOr_SharedPtr_MCPCallToolNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MemoryUpdateNode::StatusOr_SharedPtr_MemoryUpdateNode() : StatusOr_SharedPtr_MemoryUpdateNode{inworld_StatusOr_SharedPtr_MemoryUpdateNode_new()} {}
inline StatusOr_SharedPtr_MemoryUpdateNode::StatusOr_SharedPtr_MemoryUpdateNode(MemoryUpdateNode const& value) : StatusOr_SharedPtr_MemoryUpdateNode{inworld_StatusOr_SharedPtr_MemoryUpdateNode_new_rcstd_shared_ptr_Sl_inworld_graphs_MemoryUpdateNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_MemoryUpdateNode::StatusOr_SharedPtr_MemoryUpdateNode(Status const & status) : StatusOr_SharedPtr_MemoryUpdateNode{inworld_StatusOr_SharedPtr_MemoryUpdateNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_MemoryUpdateNode::ok() const { return inworld_StatusOr_SharedPtr_MemoryUpdateNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_MemoryUpdateNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MemoryUpdateNode_status(swig_self());
  return Status{swig_cres, false};
}
inline MemoryUpdateNode StatusOr_SharedPtr_MemoryUpdateNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MemoryUpdateNode_value(swig_self());
  return MemoryUpdateNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MemoryUpdateNode::StatusOr_SharedPtr_MemoryUpdateNode(StatusOr_SharedPtr_MemoryUpdateNode const & other) : StatusOr_SharedPtr_MemoryUpdateNode{inworld_StatusOr_SharedPtr_MemoryUpdateNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_MemoryRetrieveNode::StatusOr_SharedPtr_MemoryRetrieveNode() : StatusOr_SharedPtr_MemoryRetrieveNode{inworld_StatusOr_SharedPtr_MemoryRetrieveNode_new()} {}
inline StatusOr_SharedPtr_MemoryRetrieveNode::StatusOr_SharedPtr_MemoryRetrieveNode(MemoryRetrieveNode const& value) : StatusOr_SharedPtr_MemoryRetrieveNode{inworld_StatusOr_SharedPtr_MemoryRetrieveNode_new_rcstd_shared_ptr_Sl_inworld_graphs_MemoryRetrieveNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_MemoryRetrieveNode::StatusOr_SharedPtr_MemoryRetrieveNode(Status const & status) : StatusOr_SharedPtr_MemoryRetrieveNode{inworld_StatusOr_SharedPtr_MemoryRetrieveNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_MemoryRetrieveNode::ok() const { return inworld_StatusOr_SharedPtr_MemoryRetrieveNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_MemoryRetrieveNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MemoryRetrieveNode_status(swig_self());
  return Status{swig_cres, false};
}
inline MemoryRetrieveNode StatusOr_SharedPtr_MemoryRetrieveNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_MemoryRetrieveNode_value(swig_self());
  return MemoryRetrieveNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MemoryRetrieveNode::StatusOr_SharedPtr_MemoryRetrieveNode(StatusOr_SharedPtr_MemoryRetrieveNode const & other) : StatusOr_SharedPtr_MemoryRetrieveNode{inworld_StatusOr_SharedPtr_MemoryRetrieveNode_copy(other.swig_self())} {}
inline void MemoryUpdateNodeCreationConfig::llm_component_id(std::string const& llm_component_id) { inworld_MemoryUpdateNodeCreationConfig_llm_component_id_set(swig_self(), (&llm_component_id)->c_str()); }
inline std::string MemoryUpdateNodeCreationConfig::llm_component_id() const {
  auto swig_cres = inworld_MemoryUpdateNodeCreationConfig_llm_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void MemoryUpdateNodeCreationConfig::embedder_component_id(std::string const& embedder_component_id) { inworld_MemoryUpdateNodeCreationConfig_embedder_component_id_set(swig_self(), (&embedder_component_id)->c_str()); }
inline std::string MemoryUpdateNodeCreationConfig::embedder_component_id() const {
  auto swig_cres = inworld_MemoryUpdateNodeCreationConfig_embedder_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void MemoryUpdateNodeCreationConfig::memory_update_config(MemoryUpdateConfig * memory_update_config) { inworld_MemoryUpdateNodeCreationConfig_memory_update_config_set(swig_self(), memory_update_config->swig_self()); }
inline MemoryUpdateConfig * MemoryUpdateNodeCreationConfig::memory_update_config() const {
  auto swig_cres = inworld_MemoryUpdateNodeCreationConfig_memory_update_config_get(swig_self());
  return swig_cres ? new MemoryUpdateConfig(swig_cres, false) : nullptr;
}
inline MemoryUpdateNodeCreationConfig::MemoryUpdateNodeCreationConfig() : MemoryUpdateNodeCreationConfig{inworld_MemoryUpdateNodeCreationConfig_new()} {}
inline MemoryUpdateNodeCreationConfig::MemoryUpdateNodeCreationConfig(MemoryUpdateNodeCreationConfig const & other) : MemoryUpdateNodeCreationConfig{inworld_MemoryUpdateNodeCreationConfig_copy(other.swig_self())} {}
inline void MemoryRetrieveNodeCreationConfig::llm_component_id(std::string const& llm_component_id) { inworld_MemoryRetrieveNodeCreationConfig_llm_component_id_set(swig_self(), (&llm_component_id)->c_str()); }
inline std::string MemoryRetrieveNodeCreationConfig::llm_component_id() const {
  auto swig_cres = inworld_MemoryRetrieveNodeCreationConfig_llm_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void MemoryRetrieveNodeCreationConfig::embedder_component_id(std::string const& embedder_component_id) { inworld_MemoryRetrieveNodeCreationConfig_embedder_component_id_set(swig_self(), (&embedder_component_id)->c_str()); }
inline std::string MemoryRetrieveNodeCreationConfig::embedder_component_id() const {
  auto swig_cres = inworld_MemoryRetrieveNodeCreationConfig_embedder_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline MemoryRetrieveNodeCreationConfig::MemoryRetrieveNodeCreationConfig() : MemoryRetrieveNodeCreationConfig{inworld_MemoryRetrieveNodeCreationConfig_new()} {}
inline MemoryRetrieveNodeCreationConfig::MemoryRetrieveNodeCreationConfig(MemoryRetrieveNodeCreationConfig const & other) : MemoryRetrieveNodeCreationConfig{inworld_MemoryRetrieveNodeCreationConfig_copy(other.swig_self())} {}
inline void MemoryRetrieveNodeExecutionConfig::retrieval_config(RetrievalConfig * retrieval_config) { inworld_MemoryRetrieveNodeExecutionConfig_retrieval_config_set(swig_self(), retrieval_config->swig_self()); }
inline RetrievalConfig * MemoryRetrieveNodeExecutionConfig::retrieval_config() const {
  auto swig_cres = inworld_MemoryRetrieveNodeExecutionConfig_retrieval_config_get(swig_self());
  return swig_cres ? new RetrievalConfig(swig_cres, false) : nullptr;
}
inline void MemoryRetrieveNodeExecutionConfig::return_rolling_summary(bool return_rolling_summary) { inworld_MemoryRetrieveNodeExecutionConfig_return_rolling_summary_set(swig_self(), return_rolling_summary); }
inline bool MemoryRetrieveNodeExecutionConfig::return_rolling_summary() const { return inworld_MemoryRetrieveNodeExecutionConfig_return_rolling_summary_get(swig_self()); }
inline bool MemoryRetrieveNodeExecutionConfig::is_valid() const { return inworld_MemoryRetrieveNodeExecutionConfig_is_valid(swig_self()); }
inline MemoryRetrieveNodeExecutionConfig::MemoryRetrieveNodeExecutionConfig() : MemoryRetrieveNodeExecutionConfig{inworld_MemoryRetrieveNodeExecutionConfig_new()} {}
inline MemoryRetrieveNodeExecutionConfig::MemoryRetrieveNodeExecutionConfig(MemoryRetrieveNodeExecutionConfig const & other) : MemoryRetrieveNodeExecutionConfig{inworld_MemoryRetrieveNodeExecutionConfig_copy(other.swig_self())} {}
inline bool MemoryUpdateNode::is_valid() const { return inworld_MemoryUpdateNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_MemoryUpdateNode MemoryUpdateNode::inworld_inworld_graphs_MemoryUpdateNode_Create__SWIG_0(std::string const& id, CreationContext const & arg2, MemoryUpdateNodeCreationConfig const & arg3) {
  auto swig_cres = inworld_MemoryUpdateNode_Create_rcstd_string_rcinworld_CreationContext_rcinworld_graphs_MemoryUpdateNodeCreationConfig((&id)->c_str(), arg2.swig_self(), arg3.swig_self());
  return StatusOr_SharedPtr_MemoryUpdateNode{swig_cres, true};
}
inline StatusOr_SharedPtr_MemoryUpdateNode MemoryUpdateNode::inworld_inworld_graphs_MemoryUpdateNode_Create__SWIG_1(std::string const& id, CreationContext const & arg2, MemoryUpdateNodeCreationConfig const & arg3, NodeExecutionConfig const& arg4) {
  auto swig_cres = inworld_MemoryUpdateNode_Create_rcstd_string_rcinworld_CreationContext_rcinworld_graphs_MemoryUpdateNodeCreationConfig_rcstd_shared_ptr_Sl_inworld_graphs_NodeExecutionConfig_Sg_((&id)->c_str(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_SharedPtr_MemoryUpdateNode{swig_cres, true};
}
inline MemoryUpdateNode::MemoryUpdateNode(MemoryUpdateNode const & other) : MemoryUpdateNode{inworld_MemoryUpdateNode_copy(other.swig_self())} {}
inline bool MemoryRetrieveNode::is_valid() const { return inworld_MemoryRetrieveNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_MemoryRetrieveNode MemoryRetrieveNode::inworld_inworld_graphs_MemoryRetrieveNode_Create__SWIG(std::string const& id, CreationContext const & arg2, MemoryRetrieveNodeCreationConfig const & arg3, MemoryRetrieveNodeExecutionConfig const& arg4) {
  auto swig_cres = inworld_MemoryRetrieveNode_Create((&id)->c_str(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_SharedPtr_MemoryRetrieveNode{swig_cres, true};
}
inline MemoryRetrieveNode::MemoryRetrieveNode(MemoryRetrieveNode const & other) : MemoryRetrieveNode{inworld_MemoryRetrieveNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_RandomCannedTextNode::StatusOr_SharedPtr_RandomCannedTextNode() : StatusOr_SharedPtr_RandomCannedTextNode{inworld_StatusOr_SharedPtr_RandomCannedTextNode_new()} {}
inline StatusOr_SharedPtr_RandomCannedTextNode::StatusOr_SharedPtr_RandomCannedTextNode(RandomCannedTextNode const& value) : StatusOr_SharedPtr_RandomCannedTextNode{inworld_StatusOr_SharedPtr_RandomCannedTextNode_new_rcstd_shared_ptr_Sl_inworld_graphs_RandomCannedTextNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_RandomCannedTextNode::StatusOr_SharedPtr_RandomCannedTextNode(Status const & status) : StatusOr_SharedPtr_RandomCannedTextNode{inworld_StatusOr_SharedPtr_RandomCannedTextNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_RandomCannedTextNode::ok() const { return inworld_StatusOr_SharedPtr_RandomCannedTextNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_RandomCannedTextNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_RandomCannedTextNode_status(swig_self());
  return Status{swig_cres, false};
}
inline RandomCannedTextNode StatusOr_SharedPtr_RandomCannedTextNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_RandomCannedTextNode_value(swig_self());
  return RandomCannedTextNode{swig_cres, true};
}
inline StatusOr_SharedPtr_RandomCannedTextNode::StatusOr_SharedPtr_RandomCannedTextNode(StatusOr_SharedPtr_RandomCannedTextNode const & other) : StatusOr_SharedPtr_RandomCannedTextNode{inworld_StatusOr_SharedPtr_RandomCannedTextNode_copy(other.swig_self())} {}
inline void RandomCannedTextNodeExecutionConfig::canned_phrases(vector_string * canned_phrases) { inworld_RandomCannedTextNodeExecutionConfig_canned_phrases_set(swig_self(), canned_phrases->swig_self()); }
inline vector_string * RandomCannedTextNodeExecutionConfig::canned_phrases() const {
  auto swig_cres = inworld_RandomCannedTextNodeExecutionConfig_canned_phrases_get(swig_self());
  return swig_cres ? new vector_string(swig_cres, false) : nullptr;
}
inline bool RandomCannedTextNodeExecutionConfig::is_valid() const { return inworld_RandomCannedTextNodeExecutionConfig_is_valid(swig_self()); }
inline RandomCannedTextNodeExecutionConfig::RandomCannedTextNodeExecutionConfig() : RandomCannedTextNodeExecutionConfig{inworld_RandomCannedTextNodeExecutionConfig_new()} {}
inline RandomCannedTextNodeExecutionConfig::RandomCannedTextNodeExecutionConfig(RandomCannedTextNodeExecutionConfig const & other) : RandomCannedTextNodeExecutionConfig{inworld_RandomCannedTextNodeExecutionConfig_copy(other.swig_self())} {}
inline bool RandomCannedTextNode::is_valid() const { return inworld_RandomCannedTextNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_RandomCannedTextNode RandomCannedTextNode::inworld_inworld_graphs_RandomCannedTextNode_Create__SWIG(std::string const& id, RandomCannedTextNodeExecutionConfig const& arg2) {
  auto swig_cres = inworld_RandomCannedTextNode_Create((&id)->c_str(), arg2.swig_self());
  return StatusOr_SharedPtr_RandomCannedTextNode{swig_cres, true};
}
inline RandomCannedTextNode::RandomCannedTextNode(RandomCannedTextNode const & other) : RandomCannedTextNode{inworld_RandomCannedTextNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_SafetyCheckerNode::StatusOr_SharedPtr_SafetyCheckerNode() : StatusOr_SharedPtr_SafetyCheckerNode{inworld_StatusOr_SharedPtr_SafetyCheckerNode_new()} {}
inline StatusOr_SharedPtr_SafetyCheckerNode::StatusOr_SharedPtr_SafetyCheckerNode(SafetyCheckerNode const& value) : StatusOr_SharedPtr_SafetyCheckerNode{inworld_StatusOr_SharedPtr_SafetyCheckerNode_new_rcstd_shared_ptr_Sl_inworld_graphs_SafetyCheckerNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_SafetyCheckerNode::StatusOr_SharedPtr_SafetyCheckerNode(Status const & status) : StatusOr_SharedPtr_SafetyCheckerNode{inworld_StatusOr_SharedPtr_SafetyCheckerNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_SafetyCheckerNode::ok() const { return inworld_StatusOr_SharedPtr_SafetyCheckerNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_SafetyCheckerNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_SafetyCheckerNode_status(swig_self());
  return Status{swig_cres, false};
}
inline SafetyCheckerNode StatusOr_SharedPtr_SafetyCheckerNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_SafetyCheckerNode_value(swig_self());
  return SafetyCheckerNode{swig_cres, true};
}
inline StatusOr_SharedPtr_SafetyCheckerNode::StatusOr_SharedPtr_SafetyCheckerNode(StatusOr_SharedPtr_SafetyCheckerNode const & other) : StatusOr_SharedPtr_SafetyCheckerNode{inworld_StatusOr_SharedPtr_SafetyCheckerNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_SafetyResult::StatusOr_SharedPtr_SafetyResult() : StatusOr_SharedPtr_SafetyResult{inworld_StatusOr_SharedPtr_SafetyResult_new()} {}
inline StatusOr_SharedPtr_SafetyResult::StatusOr_SharedPtr_SafetyResult(SafetyResult const& value) : StatusOr_SharedPtr_SafetyResult{inworld_StatusOr_SharedPtr_SafetyResult_new_rcstd_shared_ptr_Sl_inworld_graphs_SafetyResult_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_SafetyResult::StatusOr_SharedPtr_SafetyResult(Status const & status) : StatusOr_SharedPtr_SafetyResult{inworld_StatusOr_SharedPtr_SafetyResult_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_SafetyResult::ok() const { return inworld_StatusOr_SharedPtr_SafetyResult_ok(swig_self()); }
inline Status StatusOr_SharedPtr_SafetyResult::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_SafetyResult_status(swig_self());
  return Status{swig_cres, false};
}
inline SafetyResult StatusOr_SharedPtr_SafetyResult::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_SafetyResult_value(swig_self());
  return SafetyResult{swig_cres, true};
}
inline StatusOr_SharedPtr_SafetyResult::StatusOr_SharedPtr_SafetyResult(StatusOr_SharedPtr_SafetyResult const & other) : StatusOr_SharedPtr_SafetyResult{inworld_StatusOr_SharedPtr_SafetyResult_copy(other.swig_self())} {}
inline optional_SafetyConfig::optional_SafetyConfig() : optional_SafetyConfig{inworld_optional_SafetyConfig_new()} {}
inline optional_SafetyConfig::optional_SafetyConfig(SafetyConfig const & value) : optional_SafetyConfig{inworld_optional_SafetyConfig_new_rcinworld_SafetyConfig(value.swig_self())} {}
inline optional_SafetyConfig::optional_SafetyConfig(optional_SafetyConfig const & other) : optional_SafetyConfig{inworld_optional_SafetyConfig_copy(other.swig_self())} {}
inline bool optional_SafetyConfig::has_value() const { return inworld_optional_SafetyConfig_has_value(swig_self()); }
inline SafetyConfig optional_SafetyConfig::value() {
  auto swig_cres = inworld_optional_SafetyConfig_value(swig_self());
  return SafetyConfig{swig_cres, false};
}
inline SafetyConfig optional_SafetyConfig::value() const {
  auto swig_cres = inworld_optional_SafetyConfig_valueConst(swig_self());
  return SafetyConfig{swig_cres, false};
}
inline SafetyConfig optional_SafetyConfig::value_or(SafetyConfig const & default_value) const {
  auto swig_cres = inworld_optional_SafetyConfig_value_or(swig_self(), default_value.swig_self());
  return SafetyConfig{swig_cres, true};
}
inline void optional_SafetyConfig::reset() { inworld_optional_SafetyConfig_reset(swig_self()); }
inline SafetyConfig optional_SafetyConfig::operator *() {
  auto swig_cres = inworld_optional_SafetyConfig_get(swig_self());
  return SafetyConfig{swig_cres, false};
}
inline SafetyConfig optional_SafetyConfig::operator *() const {
  auto swig_cres = inworld_optional_SafetyConfig_getConst(swig_self());
  return SafetyConfig{swig_cres, false};
}
inline SafetyConfig optional_SafetyConfig::get_value() {
  auto swig_cres = inworld_optional_SafetyConfig_get_value(swig_self());
  return SafetyConfig{swig_cres, false};
}
inline void optional_SafetyConfig::set_value(SafetyConfig & t) { inworld_optional_SafetyConfig_set_value(swig_self(), t.swig_self()); }
inline void SafetyCheckerNodeCreationConfig::embedder_component_id(std::string const& embedder_component_id) { inworld_SafetyCheckerNodeCreationConfig_embedder_component_id_set(swig_self(), (&embedder_component_id)->c_str()); }
inline std::string SafetyCheckerNodeCreationConfig::embedder_component_id() const {
  auto swig_cres = inworld_SafetyCheckerNodeCreationConfig_embedder_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void SafetyCheckerNodeCreationConfig::safety_config(SafetyCheckerCreationConfig * safety_config) { inworld_SafetyCheckerNodeCreationConfig_safety_config_set(swig_self(), safety_config->swig_self()); }
inline SafetyCheckerCreationConfig * SafetyCheckerNodeCreationConfig::safety_config() const {
  auto swig_cres = inworld_SafetyCheckerNodeCreationConfig_safety_config_get(swig_self());
  return swig_cres ? new SafetyCheckerCreationConfig(swig_cres, false) : nullptr;
}
inline SafetyCheckerNodeCreationConfig::SafetyCheckerNodeCreationConfig() : SafetyCheckerNodeCreationConfig{inworld_SafetyCheckerNodeCreationConfig_new()} {}
inline SafetyCheckerNodeCreationConfig::SafetyCheckerNodeCreationConfig(SafetyCheckerNodeCreationConfig const & other) : SafetyCheckerNodeCreationConfig{inworld_SafetyCheckerNodeCreationConfig_copy(other.swig_self())} {}
inline void SafetyCheckerNodeExecutionConfig::safety_config(optional_SafetyConfig * safety_config) { inworld_SafetyCheckerNodeExecutionConfig_safety_config_set(swig_self(), safety_config->swig_self()); }
inline optional_SafetyConfig * SafetyCheckerNodeExecutionConfig::safety_config() const {
  auto swig_cres = inworld_SafetyCheckerNodeExecutionConfig_safety_config_get(swig_self());
  return swig_cres ? new optional_SafetyConfig(swig_cres, false) : nullptr;
}
inline bool SafetyCheckerNodeExecutionConfig::is_valid() const { return inworld_SafetyCheckerNodeExecutionConfig_is_valid(swig_self()); }
inline SafetyCheckerNodeExecutionConfig::SafetyCheckerNodeExecutionConfig() : SafetyCheckerNodeExecutionConfig{inworld_SafetyCheckerNodeExecutionConfig_new()} {}
inline SafetyCheckerNodeExecutionConfig::SafetyCheckerNodeExecutionConfig(SafetyCheckerNodeExecutionConfig const & other) : SafetyCheckerNodeExecutionConfig{inworld_SafetyCheckerNodeExecutionConfig_copy(other.swig_self())} {}
inline bool SafetyCheckerNode::is_valid() const { return inworld_SafetyCheckerNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_SafetyCheckerNode SafetyCheckerNode::inworld_inworld_graphs_SafetyCheckerNode_Create__SWIG(std::string const& id, CreationContext const & arg2, SafetyCheckerNodeCreationConfig const & arg3, SafetyCheckerNodeExecutionConfig const& arg4) {
  auto swig_cres = inworld_SafetyCheckerNode_Create((&id)->c_str(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_SharedPtr_SafetyCheckerNode{swig_cres, true};
}
inline SafetyCheckerNode::SafetyCheckerNode(SafetyCheckerNode const & other) : SafetyCheckerNode{inworld_SafetyCheckerNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_STTNode::StatusOr_SharedPtr_STTNode() : StatusOr_SharedPtr_STTNode{inworld_StatusOr_SharedPtr_STTNode_new()} {}
inline StatusOr_SharedPtr_STTNode::StatusOr_SharedPtr_STTNode(STTNode const& value) : StatusOr_SharedPtr_STTNode{inworld_StatusOr_SharedPtr_STTNode_new_rcstd_shared_ptr_Sl_inworld_graphs_STTNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_STTNode::StatusOr_SharedPtr_STTNode(Status const & status) : StatusOr_SharedPtr_STTNode{inworld_StatusOr_SharedPtr_STTNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_STTNode::ok() const { return inworld_StatusOr_SharedPtr_STTNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_STTNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_STTNode_status(swig_self());
  return Status{swig_cres, false};
}
inline STTNode StatusOr_SharedPtr_STTNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_STTNode_value(swig_self());
  return STTNode{swig_cres, true};
}
inline StatusOr_SharedPtr_STTNode::StatusOr_SharedPtr_STTNode(StatusOr_SharedPtr_STTNode const & other) : StatusOr_SharedPtr_STTNode{inworld_StatusOr_SharedPtr_STTNode_copy(other.swig_self())} {}
inline void STTNodeExecutionConfig::stt_component_id(std::string const& stt_component_id) { inworld_STTNodeExecutionConfig_stt_component_id_set(swig_self(), (&stt_component_id)->c_str()); }
inline std::string STTNodeExecutionConfig::stt_component_id() const {
  auto swig_cres = inworld_STTNodeExecutionConfig_stt_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void STTNodeExecutionConfig::speech_recognition_config(optional_SpeechRecognitionConfig * speech_recognition_config) { inworld_STTNodeExecutionConfig_speech_recognition_config_set(swig_self(), speech_recognition_config->swig_self()); }
inline optional_SpeechRecognitionConfig * STTNodeExecutionConfig::speech_recognition_config() const {
  auto swig_cres = inworld_STTNodeExecutionConfig_speech_recognition_config_get(swig_self());
  return swig_cres ? new optional_SpeechRecognitionConfig(swig_cres, false) : nullptr;
}
inline bool STTNodeExecutionConfig::is_valid() const { return inworld_STTNodeExecutionConfig_is_valid(swig_self()); }
inline STTNodeExecutionConfig::STTNodeExecutionConfig() : STTNodeExecutionConfig{inworld_STTNodeExecutionConfig_new()} {}
inline STTNodeExecutionConfig::STTNodeExecutionConfig(STTNodeExecutionConfig const & other) : STTNodeExecutionConfig{inworld_STTNodeExecutionConfig_copy(other.swig_self())} {}
inline bool STTNode::is_valid() const { return inworld_STTNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_STTNode STTNode::inworld_inworld_graphs_STTNode_Create__SWIG(std::string const& id, STTNodeExecutionConfig const& arg2) {
  auto swig_cres = inworld_STTNode_Create((&id)->c_str(), arg2.swig_self());
  return StatusOr_SharedPtr_STTNode{swig_cres, true};
}
inline STTNode::STTNode(STTNode const & other) : STTNode{inworld_STTNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_TextAggregatorNode::StatusOr_SharedPtr_TextAggregatorNode() : StatusOr_SharedPtr_TextAggregatorNode{inworld_StatusOr_SharedPtr_TextAggregatorNode_new()} {}
inline StatusOr_SharedPtr_TextAggregatorNode::StatusOr_SharedPtr_TextAggregatorNode(TextAggregatorNode const& value) : StatusOr_SharedPtr_TextAggregatorNode{inworld_StatusOr_SharedPtr_TextAggregatorNode_new_rcstd_shared_ptr_Sl_inworld_graphs_TextAggregatorNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_TextAggregatorNode::StatusOr_SharedPtr_TextAggregatorNode(Status const & status) : StatusOr_SharedPtr_TextAggregatorNode{inworld_StatusOr_SharedPtr_TextAggregatorNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_TextAggregatorNode::ok() const { return inworld_StatusOr_SharedPtr_TextAggregatorNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_TextAggregatorNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_TextAggregatorNode_status(swig_self());
  return Status{swig_cres, false};
}
inline TextAggregatorNode StatusOr_SharedPtr_TextAggregatorNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_TextAggregatorNode_value(swig_self());
  return TextAggregatorNode{swig_cres, true};
}
inline StatusOr_SharedPtr_TextAggregatorNode::StatusOr_SharedPtr_TextAggregatorNode(StatusOr_SharedPtr_TextAggregatorNode const & other) : StatusOr_SharedPtr_TextAggregatorNode{inworld_StatusOr_SharedPtr_TextAggregatorNode_copy(other.swig_self())} {}
inline bool TextAggregatorNode::is_valid() const { return inworld_TextAggregatorNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_TextAggregatorNode TextAggregatorNode::inworld_inworld_graphs_TextAggregatorNode_Create__SWIG(std::string const& id, NodeExecutionConfig const& arg2) {
  auto swig_cres = inworld_TextAggregatorNode_Create((&id)->c_str(), arg2.swig_self());
  return StatusOr_SharedPtr_TextAggregatorNode{swig_cres, true};
}
inline TextAggregatorNode::TextAggregatorNode(TextAggregatorNode const & other) : TextAggregatorNode{inworld_TextAggregatorNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_TextChunkingNode::StatusOr_SharedPtr_TextChunkingNode() : StatusOr_SharedPtr_TextChunkingNode{inworld_StatusOr_SharedPtr_TextChunkingNode_new()} {}
inline StatusOr_SharedPtr_TextChunkingNode::StatusOr_SharedPtr_TextChunkingNode(TextChunkingNode const& value) : StatusOr_SharedPtr_TextChunkingNode{inworld_StatusOr_SharedPtr_TextChunkingNode_new_rcstd_shared_ptr_Sl_inworld_graphs_TextChunkingNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_TextChunkingNode::StatusOr_SharedPtr_TextChunkingNode(Status const & status) : StatusOr_SharedPtr_TextChunkingNode{inworld_StatusOr_SharedPtr_TextChunkingNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_TextChunkingNode::ok() const { return inworld_StatusOr_SharedPtr_TextChunkingNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_TextChunkingNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_TextChunkingNode_status(swig_self());
  return Status{swig_cres, false};
}
inline TextChunkingNode StatusOr_SharedPtr_TextChunkingNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_TextChunkingNode_value(swig_self());
  return TextChunkingNode{swig_cres, true};
}
inline StatusOr_SharedPtr_TextChunkingNode::StatusOr_SharedPtr_TextChunkingNode(StatusOr_SharedPtr_TextChunkingNode const & other) : StatusOr_SharedPtr_TextChunkingNode{inworld_StatusOr_SharedPtr_TextChunkingNode_copy(other.swig_self())} {}
inline void TextChunkingNodeExecutionConfig::min_chunk_length(optional_int * min_chunk_length) { inworld_TextChunkingNodeExecutionConfig_min_chunk_length_set(swig_self(), min_chunk_length->swig_self()); }
inline optional_int * TextChunkingNodeExecutionConfig::min_chunk_length() const {
  auto swig_cres = inworld_TextChunkingNodeExecutionConfig_min_chunk_length_get(swig_self());
  return swig_cres ? new optional_int(swig_cres, false) : nullptr;
}
inline bool TextChunkingNodeExecutionConfig::is_valid() const { return inworld_TextChunkingNodeExecutionConfig_is_valid(swig_self()); }
inline TextChunkingNodeExecutionConfig::TextChunkingNodeExecutionConfig() : TextChunkingNodeExecutionConfig{inworld_TextChunkingNodeExecutionConfig_new()} {}
inline TextChunkingNodeExecutionConfig::TextChunkingNodeExecutionConfig(TextChunkingNodeExecutionConfig const & other) : TextChunkingNodeExecutionConfig{inworld_TextChunkingNodeExecutionConfig_copy(other.swig_self())} {}
inline bool TextChunkingNode::is_valid() const { return inworld_TextChunkingNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_TextChunkingNode TextChunkingNode::inworld_inworld_graphs_TextChunkingNode_Create__SWIG(std::string const& id, TextChunkingNodeExecutionConfig const& arg2) {
  auto swig_cres = inworld_TextChunkingNode_Create((&id)->c_str(), arg2.swig_self());
  return StatusOr_SharedPtr_TextChunkingNode{swig_cres, true};
}
inline TextChunkingNode::TextChunkingNode(TextChunkingNode const & other) : TextChunkingNode{inworld_TextChunkingNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_TextClassifierNode::StatusOr_SharedPtr_TextClassifierNode() : StatusOr_SharedPtr_TextClassifierNode{inworld_StatusOr_SharedPtr_TextClassifierNode_new()} {}
inline StatusOr_SharedPtr_TextClassifierNode::StatusOr_SharedPtr_TextClassifierNode(TextClassifierNode const& value) : StatusOr_SharedPtr_TextClassifierNode{inworld_StatusOr_SharedPtr_TextClassifierNode_new_rcstd_shared_ptr_Sl_inworld_graphs_TextClassifierNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_TextClassifierNode::StatusOr_SharedPtr_TextClassifierNode(Status const & status) : StatusOr_SharedPtr_TextClassifierNode{inworld_StatusOr_SharedPtr_TextClassifierNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_TextClassifierNode::ok() const { return inworld_StatusOr_SharedPtr_TextClassifierNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_TextClassifierNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_TextClassifierNode_status(swig_self());
  return Status{swig_cres, false};
}
inline TextClassifierNode StatusOr_SharedPtr_TextClassifierNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_TextClassifierNode_value(swig_self());
  return TextClassifierNode{swig_cres, true};
}
inline StatusOr_SharedPtr_TextClassifierNode::StatusOr_SharedPtr_TextClassifierNode(StatusOr_SharedPtr_TextClassifierNode const & other) : StatusOr_SharedPtr_TextClassifierNode{inworld_StatusOr_SharedPtr_TextClassifierNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_ClassificationResult::StatusOr_SharedPtr_ClassificationResult() : StatusOr_SharedPtr_ClassificationResult{inworld_StatusOr_SharedPtr_ClassificationResult_new()} {}
inline StatusOr_SharedPtr_ClassificationResult::StatusOr_SharedPtr_ClassificationResult(ClassificationResult const& value) : StatusOr_SharedPtr_ClassificationResult{inworld_StatusOr_SharedPtr_ClassificationResult_new_rcstd_shared_ptr_Sl_inworld_graphs_ClassificationResult_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_ClassificationResult::StatusOr_SharedPtr_ClassificationResult(Status const & status) : StatusOr_SharedPtr_ClassificationResult{inworld_StatusOr_SharedPtr_ClassificationResult_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_ClassificationResult::ok() const { return inworld_StatusOr_SharedPtr_ClassificationResult_ok(swig_self()); }
inline Status StatusOr_SharedPtr_ClassificationResult::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_ClassificationResult_status(swig_self());
  return Status{swig_cres, false};
}
inline ClassificationResult StatusOr_SharedPtr_ClassificationResult::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_ClassificationResult_value(swig_self());
  return ClassificationResult{swig_cres, true};
}
inline StatusOr_SharedPtr_ClassificationResult::StatusOr_SharedPtr_ClassificationResult(StatusOr_SharedPtr_ClassificationResult const & other) : StatusOr_SharedPtr_ClassificationResult{inworld_StatusOr_SharedPtr_ClassificationResult_copy(other.swig_self())} {}
inline void TextClassifierNodeCreationConfig::embedder_component_id(std::string const& embedder_component_id) { inworld_TextClassifierNodeCreationConfig_embedder_component_id_set(swig_self(), (&embedder_component_id)->c_str()); }
inline std::string TextClassifierNodeCreationConfig::embedder_component_id() const {
  auto swig_cres = inworld_TextClassifierNodeCreationConfig_embedder_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void TextClassifierNodeCreationConfig::classifier_config(TextClassifierCreationConfig * classifier_config) { inworld_TextClassifierNodeCreationConfig_classifier_config_set(swig_self(), classifier_config->swig_self()); }
inline TextClassifierCreationConfig * TextClassifierNodeCreationConfig::classifier_config() const {
  auto swig_cres = inworld_TextClassifierNodeCreationConfig_classifier_config_get(swig_self());
  return swig_cres ? new TextClassifierCreationConfig(swig_cres, false) : nullptr;
}
inline TextClassifierNodeCreationConfig::TextClassifierNodeCreationConfig() : TextClassifierNodeCreationConfig{inworld_TextClassifierNodeCreationConfig_new()} {}
inline TextClassifierNodeCreationConfig::TextClassifierNodeCreationConfig(TextClassifierNodeCreationConfig const & other) : TextClassifierNodeCreationConfig{inworld_TextClassifierNodeCreationConfig_copy(other.swig_self())} {}
inline void TextClassifierNodeExecutionConfig::classifier_config(optional_TextClassifierConfig * classifier_config) { inworld_TextClassifierNodeExecutionConfig_classifier_config_set(swig_self(), classifier_config->swig_self()); }
inline optional_TextClassifierConfig * TextClassifierNodeExecutionConfig::classifier_config() const {
  auto swig_cres = inworld_TextClassifierNodeExecutionConfig_classifier_config_get(swig_self());
  return swig_cres ? new optional_TextClassifierConfig(swig_cres, false) : nullptr;
}
inline bool TextClassifierNodeExecutionConfig::is_valid() const { return inworld_TextClassifierNodeExecutionConfig_is_valid(swig_self()); }
inline TextClassifierNodeExecutionConfig::TextClassifierNodeExecutionConfig() : TextClassifierNodeExecutionConfig{inworld_TextClassifierNodeExecutionConfig_new()} {}
inline TextClassifierNodeExecutionConfig::TextClassifierNodeExecutionConfig(TextClassifierNodeExecutionConfig const & other) : TextClassifierNodeExecutionConfig{inworld_TextClassifierNodeExecutionConfig_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_TextClassifierNode TextClassifierNode::Create(std::string const& id, CreationContext const & arg2, TextClassifierNodeCreationConfig const & arg3, TextClassifierNodeExecutionConfig const & arg4) {
  auto swig_cres = inworld_TextClassifierNode_Create((&id)->c_str(), arg2.swig_self(), arg3.swig_self(), arg4.swig_self());
  return StatusOr_SharedPtr_TextClassifierNode{swig_cres, true};
}
inline bool TextClassifierNode::is_valid() const { return inworld_TextClassifierNode_is_valid(swig_self()); }
inline TextClassifierNode::TextClassifierNode(TextClassifierNode const & other) : TextClassifierNode{inworld_TextClassifierNode_copy(other.swig_self())} {}
inline StatusOr_SharedPtr_TTSNode::StatusOr_SharedPtr_TTSNode() : StatusOr_SharedPtr_TTSNode{inworld_StatusOr_SharedPtr_TTSNode_new()} {}
inline StatusOr_SharedPtr_TTSNode::StatusOr_SharedPtr_TTSNode(TTSNode const& value) : StatusOr_SharedPtr_TTSNode{inworld_StatusOr_SharedPtr_TTSNode_new_rcstd_shared_ptr_Sl_inworld_graphs_TTSNode_Sg_(value.swig_self())} {}
inline StatusOr_SharedPtr_TTSNode::StatusOr_SharedPtr_TTSNode(Status const & status) : StatusOr_SharedPtr_TTSNode{inworld_StatusOr_SharedPtr_TTSNode_new_rcabsl_Status(status.swig_self())} {}
inline bool StatusOr_SharedPtr_TTSNode::ok() const { return inworld_StatusOr_SharedPtr_TTSNode_ok(swig_self()); }
inline Status StatusOr_SharedPtr_TTSNode::status() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_TTSNode_status(swig_self());
  return Status{swig_cres, false};
}
inline TTSNode StatusOr_SharedPtr_TTSNode::value() const {
  auto swig_cres = inworld_StatusOr_SharedPtr_TTSNode_value(swig_self());
  return TTSNode{swig_cres, true};
}
inline StatusOr_SharedPtr_TTSNode::StatusOr_SharedPtr_TTSNode(StatusOr_SharedPtr_TTSNode const & other) : StatusOr_SharedPtr_TTSNode{inworld_StatusOr_SharedPtr_TTSNode_copy(other.swig_self())} {}
inline void TTSNodeExecutionConfig::tts_component_id(std::string const& tts_component_id) { inworld_TTSNodeExecutionConfig_tts_component_id_set(swig_self(), (&tts_component_id)->c_str()); }
inline std::string TTSNodeExecutionConfig::tts_component_id() const {
  auto swig_cres = inworld_TTSNodeExecutionConfig_tts_component_id_get(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline void TTSNodeExecutionConfig::voice(Voice * voice) { inworld_TTSNodeExecutionConfig_voice_set(swig_self(), voice->swig_self()); }
inline Voice * TTSNodeExecutionConfig::voice() const {
  auto swig_cres = inworld_TTSNodeExecutionConfig_voice_get(swig_self());
  return swig_cres ? new Voice(swig_cres, false) : nullptr;
}
inline void TTSNodeExecutionConfig::synthesis_config(optional_SpeechSynthesisConfig * synthesis_config) { inworld_TTSNodeExecutionConfig_synthesis_config_set(swig_self(), synthesis_config->swig_self()); }
inline optional_SpeechSynthesisConfig * TTSNodeExecutionConfig::synthesis_config() const {
  auto swig_cres = inworld_TTSNodeExecutionConfig_synthesis_config_get(swig_self());
  return swig_cres ? new optional_SpeechSynthesisConfig(swig_cres, false) : nullptr;
}
inline bool TTSNodeExecutionConfig::is_valid() const { return inworld_TTSNodeExecutionConfig_is_valid(swig_self()); }
inline TTSNodeExecutionConfig::TTSNodeExecutionConfig() : TTSNodeExecutionConfig{inworld_TTSNodeExecutionConfig_new()} {}
inline TTSNodeExecutionConfig::TTSNodeExecutionConfig(TTSNodeExecutionConfig const & other) : TTSNodeExecutionConfig{inworld_TTSNodeExecutionConfig_copy(other.swig_self())} {}
inline bool TTSNode::is_valid() const { return inworld_TTSNode_is_valid(swig_self()); }
inline StatusOr_SharedPtr_TTSNode TTSNode::inworld_inworld_graphs_TTSNode_Create__SWIG(std::string const& id, TTSNodeExecutionConfig const& arg2) {
  auto swig_cres = inworld_TTSNode_Create((&id)->c_str(), arg2.swig_self());
  return StatusOr_SharedPtr_TTSNode{swig_cres, true};
}
inline TTSNode::TTSNode(TTSNode const & other) : TTSNode{inworld_TTSNode_copy(other.swig_self())} {}
inline MemoryState::MemoryState() : MemoryState{inworld_MemoryState_new()} {}
inline MemoryState::MemoryState(MemorySnapshot const& memory_snapshot) : MemoryState{inworld_MemoryState_new_inworld_MemorySnapshot(memory_snapshot.swig_self())} {}
inline MemorySnapshot MemoryState::memory_snapshot() const {
  auto swig_cres = inworld_MemoryState_memory_snapshot(swig_self());
  return MemorySnapshot{swig_cres, false};
}
inline bool MemoryState::is_valid() const { return inworld_MemoryState_is_valid(swig_self()); }
inline std::string MemoryState::GetJson() {
  auto swig_cres = inworld_MemoryState_GetJson(swig_self());
  auto&& swig_cxxres = std::string(swig_cres);
  free(const_cast<char*>(swig_cres));
  return swig_cxxres;
}
inline MemoryState::MemoryState(MemoryState const & other) : MemoryState{inworld_MemoryState_copy(other.swig_self())} {}

}

#endif /* __cplusplus */

#endif /* SWIG_inworld_WRAP_H_ */
