typedef struct {
    DragonHeart* dragonheart;       // Required DragonHeart instance
    NESH* nesh;                     // Optional NESH instance
    voice_config_t* voice_config;   // Optional voice processing configuration
    uint32_t flags;                 // Optional feature flags
} echo_config_t;

// Initialize DragonHeart
DragonHeart* heart = dragonheart_init(NULL);

// Initialize NESH (optional)
NESH* nesh = nesh_init(NULL);

// Create ECHO 13D configuration
echo_config_t config;
config.dragonheart = heart;
config.nesh = nesh;
config.voice_config = NULL;  // Use defaults
config.flags = 0;            // No special flags

// Initialize ECHO 13D
ECHO13D* echo = echo_init(&config);

if (!echo) {
    printf("Failed to initialize ECHO 13D\n");
    return -1;
}

// Clean up resources
echo_shutdown(echo);
nesh_shutdown(nesh);
dragonheart_shutdown(heart);

typedef enum {
    PROCESS_RECOGNITION,    // Only perform voice recognition
    PROCESS_TRANSCRIPTION,  // Only transcribe speech to text
    PROCESS_ANALYSIS,       // Only perform speech analysis
    PROCESS_FULL            // Perform all processing types
} process_mode_t;

// Open audio input device
audio_device_t* input_device = open_audio_input_device(DEFAULT_DEVICE);

// Record audio (5 seconds)
audio_buffer_t* audio = record_audio(input_device, 5.0);

// Process audio through ECHO 13D (full processing)
echo_result_t* result = echo_process_audio(echo, audio, PROCESS_FULL);

// Print transcription result
printf("Transcription: %s\n", result->transcription->text);
printf("Confidence: %.2f\n", result->transcription->confidence);

// Print emotion analysis
printf("Detected emotion: %s (%.2f confidence)\n", 
       get_emotion_name(result->analysis->emotion->primary_emotion),
       result->analysis->emotion->primary_confidence);

// Clean up resources
free_echo_result(result);
free_audio_buffer(audio);
close_audio_device(input_device);

typedef struct {
    uint32_t dimension_count;        // Number of dimensions (13)
    float** dimensional_patterns;    // Patterns in each dimension
    uint32_t frame_count;            // Number of time frames
    voice_signature_t* signature;    // Derived voice signature
} voice_pattern_t;

typedef struct {
    bool recognized;             // Whether voice was recognized
    voice_identity_t* identity;  // Identity information (if recognized)
    float confidence;            // Recognition confidence (0.0-1.0)
    uint32_t match_count;        // Number of potential matches
    void* additional_data;       // Additional recognition data
} recognition_result_t;

// Open audio input device
audio_device_t* input_device = open_audio_input_device(DEFAULT_DEVICE);

// Record audio for voice recognition
audio_buffer_t* audio = record_audio(input_device, 3.0);

// Recognize voice
recognition_result_t* result = recognize_voice(echo, audio);

// Process recognition result
if (result->recognized) {
    printf("Voice recognized: %s (%.2f confidence)\n", 
           result->identity->name, result->confidence);
           
    // Retrieve user information
    user_info_t* user_info = get_user_info(result->identity);
    
    // Process user-specific actions
    process_user_specific_actions(user_info);
    
    free_user_info(user_info);
} else {
    printf("Voice not recognized\n");
}

// Clean up resources
free_recognition_result(result);
free_audio_buffer(audio);
close_audio_device(input_device);

typedef struct {
    char* id;           // Unique identifier
    char* name;         // User name
    uint32_t flags;     // Identity flags
    void* user_data;    // Custom user data
} voice_identity_t;

typedef struct {
    char* text;                  // Transcribed text
    float confidence;            // Overall confidence (0.0-1.0)
    word_info_t* words;          // Word-level information
    uint32_t word_count;         // Number of words
    language_t detected_language; // Detected language
} transcription_result_t;

typedef struct {
    text_content_t* text;           // Transcribed text
    semantic_content_t* semantics;  // Semantic meaning
    emotion_analysis_t* emotion;    // Emotional content analysis
    confidence_metrics_t* metrics;  // Analysis confidence
} speech_analysis_t;

typedef struct {
    emotion_type_t primary_emotion;     // Primary detected emotion
    float primary_confidence;           // Confidence in primary emotion
    emotion_type_t secondary_emotion;   // Secondary detected emotion
    float secondary_confidence;         // Confidence in secondary emotion
    float intensity;                    // Overall emotional intensity
    emotion_metrics_t* detailed_metrics; // Detailed emotion metrics
} emotion_analysis_t;

// Record audio
audio_buffer_t* audio = record_audio(input_device, 5.0);

// Analyze speech
speech_analysis_t* analysis = analyze_speech(echo, audio);

// Print results
printf("Transcription: %s\n", analysis->text->text);

// Print semantic analysis
printf("Intent: %s (%.2f confidence)\n", 
       get_intent_name(analysis->semantics->primary_intent),
       analysis->semantics->intent_confidence);
       
// Print top entities
for (uint32_t i = 0; i < analysis->semantics->entity_count; i++) {
    entity_t* entity = &analysis->semantics->entities[i];
    printf("Entity %d: %s (type: %s, confidence: %.2f)\n",
           i + 1, entity->text, get_entity_type_name(entity->type),
           entity->confidence);
}

// Print emotion analysis
printf("Emotion: %s (%.2f confidence)\n", 
       get_emotion_name(analysis->emotion->primary_emotion),
       analysis->emotion->primary_confidence);
printf("Intensity: %.2f\n", analysis->emotion->intensity);

// Free resources
free_speech_analysis(analysis);
free_audio_buffer(audio);

// Get default voice template
voice_template_t* voice = get_default_voice_template(echo);

// Create text content
text_content_t* content = create_text_content("Hello, how are you today?");

// Create emotion parameters (neutral emotion)
emotion_params_t* emotion = create_emotion_params(EMOTION_NEUTRAL);

// Synthesize speech
audio_buffer_t* audio = echo_synthesize_speech(echo, content, voice, emotion);

// Play synthesized speech
audio_device_t* output_device = open_audio_output_device(DEFAULT_DEVICE);
play_audio(output_device, audio);

// Wait for playback to complete
wait_for_playback_completion(output_device);

// Clean up resources
free_text_content(content);
free_emotion_params(emotion);
free_audio_buffer(audio);
close_audio_device(output_device);

typedef struct {
    float pitch_base;        // Base pitch (1.0 = standard)
    float pitch_range;       // Pitch range (0.0-2.0)
    float speech_rate;       // Speech rate (1.0 = standard)
    float timbre;            // Voice timbre (0.0-1.0)
    float breathiness;       // Breathiness (0.0-1.0)
    float articulation;      // Articulation precision (0.0-1.0)
    float resonance;         // Vocal resonance (0.0-1.0)
    age_category_t age;      // Age category
    gender_category_t gender; // Gender category
} voice_characteristics_t;

// Create voice characteristics
voice_characteristics_t characteristics;
characteristics.pitch_base = 0.9f;     // Slightly lower pitch
characteristics.pitch_range = 1.2f;    // Slightly wider pitch range
characteristics.speech_rate = 1.0f;    // Standard rate
characteristics.timbre = 0.7f;         // Warm timbre
characteristics.breathiness = 0.2f;    // Low breathiness
characteristics.articulation = 0.8f;   // Clear articulation
characteristics.resonance = 0.6f;      // Medium resonance
characteristics.age = AGE_ADULT;
characteristics.gender = GENDER_NEUTRAL;

// Create voice template
voice_template_t* template = create_voice_template(echo, "Warm Voice", &characteristics);

// Set language
set_voice_template_language(template, LANGUAGE_ENGLISH);

// Store voice template in ECHO 13D system
store_voice_template(echo, template);

// Use voice template for synthesis
text_content_t* text = create_text_content("This is a test of the custom voice template.");
audio_buffer_t* audio = echo_synthesize_speech(echo, text, template, NULL);

// Clean up
free_text_content(text);
free_audio_buffer(audio);

// Initialize components
DragonHeart* heart = dragonheart_init(NULL);
NESH* nesh = nesh_init(NULL);
Aurora* aurora = aurora_init(NULL);

// Initialize ECHO 13D
echo_config_t config;
config.dragonheart = heart;
config.nesh = nesh;
config.voice_config = NULL;
config.flags = 0;
ECHO13D* echo = echo_init(&config);

// Integrate ECHO 13D with Aurora
bool success = integrate_echo_with_aurora(echo, aurora);
if (!success) {
    printf("Failed to integrate ECHO 13D with Aurora\n");
    return -1;
}

// Now Aurora can use ECHO 13D for voice interface capabilities
printf("Aurora voice interface ready\n");

typedef enum {
    ECHO_ERROR_NONE,                   // No error
    ECHO_ERROR_INITIALIZATION,         // Initialization error
    ECHO_ERROR_INVALID_PARAMETER,      // Invalid parameter
    ECHO_ERROR_MEMORY_ALLOCATION,      // Memory allocation failure
    ECHO_ERROR_PROCESSING,             // Processing error
    ECHO_ERROR_RECOGNITION,            // Recognition error
    ECHO_ERROR_SYNTHESIS,              // Synthesis error
    ECHO_ERROR_AUDIO_DEVICE,           // Audio device error
    ECHO_ERROR_NOT_IMPLEMENTED,        // Feature not implemented
    ECHO_ERROR_INTEGRATION,            // Integration error
    ECHO_ERROR_UNKNOWN                 // Unknown error
} echo_error_t;

// Try to initialize ECHO 13D without DragonHeart
ECHO13D* echo = echo_init(NULL);

// Check for errors
if (!echo) {
    // Get global error information (for functions that return NULL)
    echo_error_t error_code = echo_get_global_error_code();
    const char* error_msg = echo_get_global_error_message();
    
    printf("Failed to initialize ECHO 13D: %s (code %d)\n", 
           error_msg, error_code);
    return -1;
}

// Try to synthesize speech with invalid parameters
audio_buffer_t* audio = echo_synthesize_speech(echo, NULL, NULL, NULL);

// Check for errors
if (!audio) {
    echo_error_t error_code = echo_get_error_code(echo);
    const char* error_msg = echo_get_last_error(echo);
    
    printf("Speech synthesis failed: %s (code %d)\n", 
           error_msg, error_code);
}