reneco-advanced-input-module 0.0.1

package/dist/components/voice-input-module.js

@@ -0,0 +1,1292 @@
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { d as defineCustomElement$2 } from './file-uploader2.js';
+
+class AudioRecorderService {
+    constructor() {
+        this.mediaRecorder = null;
+        this.audioChunks = [];
+        this.stream = null;
+    }
+    async startRecording() {
+        try {
+            // Check if the API exists before calling
+            if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+                console.error('Failed to start recording:', 'Microphone access is not supported in this browser or the page is not served over HTTPS/localhost.');
+                return; // Exit gracefully instead of throwing
+            }
+            this.stream = await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    echoCancellation: true,
+                    noiseSuppression: true,
+                    autoGainControl: true
+                }
+            });
+            this.audioChunks = [];
+            this.mediaRecorder = new MediaRecorder(this.stream, {
+                mimeType: 'audio/webm;codecs=opus'
+            });
+            this.mediaRecorder.ondataavailable = (event) => {
+                if (event.data && event.data.size > 0) {
+                    this.audioChunks.push(event.data);
+                }
+            };
+            this.mediaRecorder.start(100); // Collect data every 100ms
+        }
+        catch (error) {
+            console.error('Failed to start recording:', error);
+        }
+    }
+    async stopRecording() {
+        return new Promise((resolve, reject) => {
+            if (!this.mediaRecorder) {
+                reject(new Error('No active recording found'));
+                return;
+            }
+            this.mediaRecorder.onstop = () => {
+                const audioBlob = new Blob(this.audioChunks, { type: 'audio/webm' });
+                this.cleanup();
+                resolve(audioBlob);
+            };
+            this.mediaRecorder.onerror = (event) => {
+                reject(new Error(`Recording error: ${event}`));
+            };
+            this.mediaRecorder.stop();
+        });
+    }
+    isRecording() {
+        var _a;
+        return ((_a = this.mediaRecorder) === null || _a === void 0 ? void 0 : _a.state) === 'recording';
+    }
+    cleanup() {
+        if (this.stream) {
+            this.stream.getTracks().forEach(track => track.stop());
+            this.stream = null;
+        }
+        this.mediaRecorder = null;
+        this.audioChunks = [];
+    }
+}
+
+class WhisperSpeechToTextService {
+    constructor(config) {
+        // Get API key from config or environment
+        this.apiKey = (config === null || config === void 0 ? void 0 : config.apiKey) || this.getEnvironmentVariable('OPENAI_API_KEY') || '';
+        this.baseUrl = (config === null || config === void 0 ? void 0 : config.baseUrl) || 'https://api.openai.com/v1';
+        if (!this.apiKey) {
+            throw new Error('OpenAI API key is required for Whisper service');
+        }
+    }
+    getEnvironmentVariable(name) {
+        // In browser environment, we might get env vars through other means
+        if (typeof process !== 'undefined' && process.env) {
+            return process.env[name];
+        }
+        // Check if it's available as a global variable or through other means
+        return window[name] || undefined;
+    }
+    async transcribe(audioBlob, lang = 'en') {
+        var _a;
+        try {
+            const formData = new FormData();
+            // Convert webm to a format Whisper can handle
+            const audioFile = new File([audioBlob], 'audio.webm', { type: 'audio/webm' });
+            formData.append('file', audioFile);
+            formData.append('model', 'gpt-4o-transcribe'); // >>> tronque le texte ?
+            // formData.append('model', 'gpt-4o-mini-transcribe');// >>> tronque le texte ?
+            // formData.append('model', 'whisper-1');
+            formData.append('language', lang);
+            formData.append('response_format', 'json');
+            formData.append('max_output_tokens', '2000');
+            const response = await fetch(`${this.baseUrl}/audio/transcriptions`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+                body: formData,
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+                throw new Error(`Transcription failed: ${((_a = errorData.error) === null || _a === void 0 ? void 0 : _a.message) || response.statusText}`);
+            }
+            const result = await response.json();
+            return result.text || '';
+        }
+        catch (error) {
+            throw new Error(`Speech-to-text transcription failed: ${error.message}`);
+        }
+    }
+}
+class SpeechToTextServiceFactory {
+    static create(config) {
+        var _a;
+        const provider = ((_a = config.speechToText) === null || _a === void 0 ? void 0 : _a.provider) || 'whisper';
+        switch (provider) {
+            case 'whisper':
+                return new WhisperSpeechToTextService(config.speechToText);
+            default:
+                throw new Error(`Unsupported speech-to-text provider: ${provider}`);
+        }
+    }
+}
+
+class OpenAILLMService {
+    constructor(config) {
+        // Get API key from config or environment
+        this.apiKey = (config === null || config === void 0 ? void 0 : config.apiKey) || this.getEnvironmentVariable('OPENAI_API_KEY') || '';
+        // the newest OpenAI model is "gpt-4.1-mini". do not change this unless explicitly requested by the user
+        // this.model = config?.model || 'gpt-4.1-mini';
+        this.model = (config === null || config === void 0 ? void 0 : config.model) || 'gpt-4.1';
+        this.baseUrl = (config === null || config === void 0 ? void 0 : config.baseUrl) || 'https://api.openai.com/v1';
+        if (!this.apiKey) {
+            throw new Error('OpenAI API key is required for LLM service');
+        }
+    }
+    getEnvironmentVariable(name) {
+        // In browser environment, we might get env vars through other means
+        if (typeof process !== 'undefined' && process.env) {
+            return process.env[name];
+        }
+        // Check if it's available as a global variable or through other means
+        return window[name] || undefined;
+    }
+    getOptimizeFieldsDescription(schema) {
+        return Object.values(schema).map((field) => {
+            var _a;
+            return `- ${(_a = field.name) !== null && _a !== void 0 ? _a : field.title} ` +
+                `(${field.type}` +
+                `${field.required ? ', required' : ''}` +
+                `${field.readonly ? ', readonly' : ''}` +
+                `${field.min && field.min !== "" ? ', min=' + field.min : ''}` +
+                `${field.max && field.max !== "" ? ', max=' + field.max : ''}` +
+                `)` +
+                `${field.options ? ` - options: ${field.options.join(', ')}` : ''}`;
+        }).join('\n');
+    }
+    async fillFormFromTranscription(transcription, schema) {
+        return this.fillForm(transcription, schema, true);
+    }
+    async fillFormFromJson(json, schema) {
+        return this.fillForm(json, schema, false);
+    }
+    async fillForm(data, schema, dataIsTranscription = true) {
+        var _a, _b;
+        try {
+            // Handle complex schema format with fields array
+            if ((schema === null || schema === void 0 ? void 0 : schema.fields) || (schema === null || schema === void 0 ? void 0 : schema.schema)) {
+                const finalSchema = (schema === null || schema === void 0 ? void 0 : schema.fields) || (schema === null || schema === void 0 ? void 0 : schema.schema);
+                const systemPrompt = `You are an expert form-filling assistant. You will receive a voice transcription and form field definitions. Your task is to extract values from the spoken content.
+          Rules:
+          1. Only extract values that can be confidently determined from the transcription
+          2. Respect field types (string, number, datetime, boolean, select)
+          3. For datetime fields, use ISO format (YYYY-MM-DDTHH:MM)
+          4. For date fields, use the following format: DD/MM/YYY
+          5. For boolean fields, interpret yes/no, true/false, positive/negative responses
+          6. For select fields, use exact option values from the provided choices
+          7. Only include fields where relevant information is found
+          8. The current GMT datetime is ${new Date().toGMTString()}
+          9. Respect the constraints written between parenthesis for readonly status (readonly fields must not be filled with values), min and max values, whatever the transcription says
+
+          Respond with JSON in this exact format: {"fields": [{"name": "field_name", "value": "extracted_value"}]}`;
+                let userPrompt = `
+          Voice transcription: "${data}"
+
+          Form fields:
+          ${this.getOptimizeFieldsDescription(finalSchema)}
+
+          Please extract values from the Transcription for these fields.
+        `;
+                //TODO
+                // const userPrompt = (
+                //   dataIsTranscription 
+                //   ?
+                //   `Voice transcription: "${data}"`
+                //   : 
+                //   `Json datas: "${JSON.stringify(data)}"`
+                //   )+`
+                //   Form fields:
+                //   ${this.getOptimizeFieldsDescription(finalSchema)}
+                //   Please extract values from the ` + 
+                //   (
+                //   dataIsTranscription 
+                //   ?
+                //   `Transcription`
+                //   : 
+                //   `Json generated file`
+                //   )+` for these fields.`;
+                const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model: this.model,
+                        messages: [
+                            { role: 'system', content: systemPrompt },
+                            { role: 'user', content: userPrompt }
+                        ],
+                        response_format: { type: 'json_object' },
+                        temperature: 0.1,
+                    }),
+                });
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+                    throw new Error(`LLM API failed: ${((_a = errorData.error) === null || _a === void 0 ? void 0 : _a.message) || response.statusText}`);
+                }
+                const result = await response.json();
+                return JSON.parse(result.choices[0].message.content);
+            }
+            // Handle simple schema format (backward compatibility)
+            const systemPrompt = `You are an expert form-filling assistant. You will receive a voice transcription and a JSON form schema. Your task is to intelligently fill the form fields based on the spoken content.
+        Rules:
+        1. Only fill fields that can be confidently determined from the transcription
+        2. Respect field types (string, number, date, boolean, select)
+        3. For datetime fields, use ISO format (YYYY-MM-DDTHH:MM)
+        4. For date fields, use the following format: DD/MM/YYY
+        5. For boolean fields, interpret yes/no, true/false, positive/negative responses
+        6. For select fields, match the closest option from the provided choices
+        7. Leave fields empty if no relevant information is found
+        8. Return the same schema structure with 'default' values filled
+        9. The current GMT datetime is ${new Date().toGMTString()}
+        10. Respect the constraints written between parenthesis for readonly status (readonly fields must not be filled with values), min and max values, whatever the transcription says
+
+        Respond with JSON in this exact format: {"schema": {...}}`;
+            let userPrompt = `
+          Voice transcription: "${data}"
+
+          Form schema to fill:
+          ${JSON.stringify(schema, null, 2)}
+
+          Please fill the form fields based on the Transcription and return the schema with default values populated.
+        `;
+            // const userPrompt = (
+            //   dataIsTranscription 
+            //   ?
+            //   `Voice transcription: "${data}"`
+            //   : 
+            //   `Json datas: "${JSON.stringify(data)}"`
+            //   )+`
+            //   Form schema to fill:
+            //   ${JSON.stringify(schema, null, 2)}
+            //   Please fill the form fields based on the ` + 
+            //   (
+            //   dataIsTranscription 
+            //   ?
+            //   `Transcription`
+            //   : 
+            //   `Json generated file`
+            //   )+` nd return the schema with default values populated.`;
+            const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    messages: [
+                        { role: 'system', content: systemPrompt },
+                        { role: 'user', content: userPrompt }
+                    ],
+                    response_format: { type: 'json_object' },
+                    temperature: 0.1, // Low temperature for consistency
+                }),
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+                throw new Error(`LLM API failed: ${((_b = errorData.error) === null || _b === void 0 ? void 0 : _b.message) || response.statusText}`);
+            }
+            const result = await response.json();
+            const filledSchema = JSON.parse(result.choices[0].message.content);
+            // Validate that the response has the correct structure
+            if (!filledSchema.schema) {
+                throw new Error('Invalid response format from LLM service');
+            }
+            return filledSchema;
+        }
+        catch (error) {
+            throw new Error(`Form filling failed: ${error.message}`);
+        }
+    }
+}
+class LLMServiceFactory {
+    static create(config) {
+        var _a;
+        const provider = ((_a = config.llm) === null || _a === void 0 ? void 0 : _a.provider) || 'openai';
+        switch (provider) {
+            case 'openai':
+                return new OpenAILLMService(config.llm);
+            default:
+                throw new Error(`Unsupported LLM provider: ${provider}`);
+        }
+    }
+}
+
+class SchemaConverter {
+    /**
+     * Convert XML form definition to JSON schema
+     */
+    static convertXmlToJsonLegacy(xmlForm) {
+        try {
+            const parser = new DOMParser();
+            const xmlDoc = parser.parseFromString(xmlForm, 'text/xml');
+            if (xmlDoc.querySelector('parsererror')) {
+                throw new Error('Invalid XML format');
+            }
+            const schema = {
+                schema: {}
+            };
+            // Extract form title and description
+            const formElement = xmlDoc.querySelector('form');
+            if (formElement) {
+                schema.title = formElement.getAttribute('title') || undefined;
+                schema.description = formElement.getAttribute('description') || undefined;
+            }
+            // Process input fields
+            const inputs = xmlDoc.querySelectorAll('input, select, textarea');
+            inputs.forEach(input => {
+                const name = input.getAttribute('name');
+                if (!name)
+                    return;
+                const field = {
+                    type: this.mapXmlTypeToJsonTypeLegacy(input.tagName.toLowerCase(), input.getAttribute('type')),
+                    title: input.getAttribute('title') || input.getAttribute('placeholder') || name,
+                    description: input.getAttribute('description') || undefined,
+                    required: input.hasAttribute('required'),
+                    default: input.getAttribute('value') || undefined
+                };
+                // Handle select options
+                if (input.tagName.toLowerCase() === 'select') {
+                    const options = Array.from(input.querySelectorAll('option')).map(option => option.textContent || option.getAttribute('value') || '');
+                    if (options.length > 0) {
+                        field.options = options;
+                    }
+                }
+                // Handle validation attributes
+                const min = input.getAttribute('min');
+                const max = input.getAttribute('max');
+                const pattern = input.getAttribute('pattern');
+                if (min)
+                    field.min = parseFloat(min);
+                if (max)
+                    field.max = parseFloat(max);
+                if (pattern)
+                    field.pattern = pattern;
+                schema.schema[name] = field;
+            });
+            return schema;
+        }
+        catch (error) {
+            throw new Error(`XML to JSON conversion failed: ${error.message}`);
+        }
+    }
+    /**
+     * Convert JSON schema to XML form definition
+     */
+    static convertJsonToXmlLegacy(jsonForm) {
+        try {
+            const doc = document.implementation.createDocument('', '', null);
+            const form = doc.createElement('form');
+            if (jsonForm.title) {
+                form.setAttribute('title', jsonForm.title);
+            }
+            if (jsonForm.description) {
+                form.setAttribute('description', jsonForm.description);
+            }
+            Object.entries(jsonForm.schema).forEach(([fieldName, field]) => {
+                var _a;
+                // Inject default value from root if present
+                const valueFromRoot = jsonForm[fieldName];
+                const fieldWithDefault = Object.assign(Object.assign({}, field), { default: (_a = field.default) !== null && _a !== void 0 ? _a : valueFromRoot // field.default has priority
+                 });
+                const element = this.createXmlElementLegacy(doc, fieldName, fieldWithDefault);
+                if (element) {
+                    form.appendChild(element);
+                }
+            });
+            doc.appendChild(form);
+            const serializer = new XMLSerializer();
+            return serializer.serializeToString(doc);
+        }
+        catch (error) {
+            throw new Error(`JSON to XML conversion failed: ${error.message}`);
+        }
+    }
+    static mapXmlTypeToJsonTypeLegacy(tagName, type) {
+        switch (tagName) {
+            case 'select':
+                return 'select';
+            case 'textarea':
+                return 'string';
+            case 'input':
+                switch (type) {
+                    case 'number':
+                    case 'range':
+                        return 'number';
+                    case 'date':
+                    case 'datetime-local':
+                    case 'time':
+                        return 'date';
+                    case 'checkbox':
+                        return 'boolean';
+                    default:
+                        return 'string';
+                }
+            default:
+                return 'string';
+        }
+    }
+    static createXmlElementLegacy(doc, fieldName, field) {
+        let element;
+        switch (field.type) {
+            case 'select':
+                element = doc.createElement('select');
+                if (field.options) {
+                    field.options.forEach(option => {
+                        const optionElement = doc.createElement('option');
+                        optionElement.setAttribute('value', option);
+                        optionElement.textContent = option;
+                        // Set selected if it matches the default value
+                        if (field.default !== undefined && field.default === option) {
+                            optionElement.setAttribute('selected', 'true');
+                        }
+                        element.appendChild(optionElement);
+                    });
+                }
+                break;
+            case 'boolean':
+                element = doc.createElement('input');
+                element.setAttribute('type', 'checkbox');
+                if (field.default === true || field.default === 'true') {
+                    element.setAttribute('checked', 'true');
+                }
+                break;
+            case 'number':
+                element = doc.createElement('input');
+                element.setAttribute('type', 'number');
+                if (field.min !== undefined)
+                    element.setAttribute('min', field.min.toString());
+                if (field.max !== undefined)
+                    element.setAttribute('max', field.max.toString());
+                if (field.default !== undefined)
+                    element.setAttribute('value', field.default.toString());
+                break;
+            case 'date':
+                element = doc.createElement('input');
+                element.setAttribute('type', 'date');
+                if (field.default !== undefined)
+                    element.setAttribute('value', field.default.toString());
+                break;
+            default: // string, text, etc.
+                element = doc.createElement('input');
+                element.setAttribute('type', 'text');
+                if (field.default !== undefined)
+                    element.setAttribute('value', field.default.toString());
+        }
+        element.setAttribute('name', fieldName);
+        element.setAttribute('title', field.title);
+        if (field.description) {
+            element.setAttribute('description', field.description);
+        }
+        if (field.required) {
+            element.setAttribute('required', 'true');
+        }
+        if (field.pattern) {
+            element.setAttribute('pattern', field.pattern);
+        }
+        return element;
+    }
+    /**
+     * Convert new XML form definition to JSON schema
+     */
+    static async convertXmlToJson(xmlForm, classificationRootURL = "http://localhost", lang = 'en') {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+        try {
+            const parser = new DOMParser();
+            const xmlDoc = parser.parseFromString(xmlForm, 'text/xml');
+            if (xmlDoc.querySelector('parsererror')) {
+                throw new Error('Invalid XML format');
+            }
+            // Root Xforms element (optional)
+            const xforms = xmlDoc.querySelector('Xforms');
+            if (!xforms)
+                throw new Error('No Xforms root element found');
+            const fields = xforms.querySelectorAll('Fields');
+            if (fields.length === 0)
+                throw new Error('No Fields elements found');
+            const schema = {
+                fields: {}
+            };
+            for (const fieldEl of Array.from(fields)) {
+                // Read key info
+                const name = (_b = (_a = fieldEl.querySelector('SystemName')) === null || _a === void 0 ? void 0 : _a.textContent) === null || _b === void 0 ? void 0 : _b.trim();
+                if (!name)
+                    return;
+                const helpText = (_d = (_c = fieldEl.querySelector('HelpText')) === null || _c === void 0 ? void 0 : _c.textContent) === null || _d === void 0 ? void 0 : _d.trim();
+                const defaultValue = (_e = fieldEl.querySelector('DefaultValue')) === null || _e === void 0 ? void 0 : _e.textContent;
+                const enabledText = ((_g = (_f = fieldEl.querySelector('Enabled')) === null || _f === void 0 ? void 0 : _f.textContent) === null || _g === void 0 ? void 0 : _g.trim().toLowerCase()) || 'true';
+                const isEnabled = enabledText === 'true';
+                // keep as memory
+                const field_ID = (_h = fieldEl.querySelector('ID')) === null || _h === void 0 ? void 0 : _h.textContent;
+                const field_TFie_PK_ID = (_j = fieldEl.querySelector('TFie_PK_ID')) === null || _j === void 0 ? void 0 : _j.textContent;
+                const field_TVal_PK_ID = (_k = fieldEl.querySelector('TVal_PK_ID')) === null || _k === void 0 ? void 0 : _k.textContent;
+                const field_TFIn_PK_ID = (_l = fieldEl.querySelector('TFIn_PK_ID')) === null || _l === void 0 ? void 0 : _l.textContent;
+                const field_isForm = (_m = fieldEl.querySelector('isForm')) === null || _m === void 0 ? void 0 : _m.textContent;
+                const field_LabelText = (_o = fieldEl.querySelector('LabelText')) === null || _o === void 0 ? void 0 : _o.textContent;
+                const field_SystemName = (_p = fieldEl.querySelector('SystemName')) === null || _p === void 0 ? void 0 : _p.textContent;
+                const field_CssStyle = (_q = fieldEl.querySelector('CssStyle')) === null || _q === void 0 ? void 0 : _q.textContent;
+                const field_ControlType = ((_r = fieldEl.querySelector('ControlType')) === null || _r === void 0 ? void 0 : _r.textContent) || 'TextBox';
+                const field_ValidationRequired = (_s = fieldEl.querySelector('ValidationRequired')) === null || _s === void 0 ? void 0 : _s.textContent;
+                const field_ValidationMin = (_t = fieldEl.querySelector('ValidationMin')) === null || _t === void 0 ? void 0 : _t.textContent;
+                const field_ValidationMax = (_u = fieldEl.querySelector('ValidationMax')) === null || _u === void 0 ? void 0 : _u.textContent;
+                const field_Mask = (_v = fieldEl.querySelector('Mask')) === null || _v === void 0 ? void 0 : _v.textContent;
+                const field_TypeId = (_w = fieldEl.querySelector('TypeId')) === null || _w === void 0 ? void 0 : _w.textContent;
+                const field_Unit = (_x = fieldEl.querySelector('Unit')) === null || _x === void 0 ? void 0 : _x.textContent;
+                const field_TFie_Fullpath = (_y = fieldEl.querySelector('TFie_Fullpath')) === null || _y === void 0 ? void 0 : _y.textContent;
+                const field_TVal_FK_Parent_ID = (_z = fieldEl.querySelector('TVal_FK_Parent_ID')) === null || _z === void 0 ? void 0 : _z.textContent;
+                const field = {
+                    type: this.mapControlTypeToJsonType(field_ControlType),
+                    title: field_LabelText,
+                    description: helpText,
+                    required: (field_ValidationRequired === null || field_ValidationRequired === void 0 ? void 0 : field_ValidationRequired.toLowerCase()) === 'required',
+                    default: defaultValue || undefined,
+                    realType: field_ControlType,
+                    Enabled: isEnabled,
+                    ID: field_ID,
+                    TFie_PK_ID: field_TFie_PK_ID,
+                    TVal_PK_ID: field_TVal_PK_ID,
+                    TFIn_PK_ID: field_TFIn_PK_ID,
+                    isForm: field_isForm,
+                    LabelText: field_LabelText,
+                    SystemName: field_SystemName,
+                    CssStyle: field_CssStyle,
+                    ControlType: field_ControlType,
+                    ValidationRequired: field_ValidationRequired,
+                    ValidationMin: field_ValidationMin,
+                    ValidationMax: field_ValidationMax,
+                    Mask: field_Mask,
+                    TypeId: field_TypeId,
+                    Unit: field_Unit,
+                    TFie_Fullpath: field_TFie_Fullpath,
+                    TVal_FK_Parent_ID: field_TVal_FK_Parent_ID
+                };
+                // Handle select options
+                if (field.type.toLowerCase() === 'select') {
+                    try {
+                        const response = await fetch(`${classificationRootURL}/api/v1/classification/getList/${field.ControlType.toLowerCase() == 'termpicker' ? "position" : "thesaurus"}/?StartNodeID=${field_TypeId}&Language=${lang}`);
+                        if (!response.ok)
+                            throw new Error(`HTTP error! status: ${response.status}`);
+                        const data = await response.json();
+                        if (Array.isArray(data)) {
+                            const options = data.map(item => ({
+                                value: item.ID,
+                                label: item.System_Name
+                            }));
+                            if (options.length > 0) {
+                                field.pickerOptions = options;
+                                // TODO on degage les quotes simples temporairement, a corriger
+                                field.options = options.map(option => option.label.replace("'", ""));
+                            }
+                        }
+                        else {
+                            console.error("Unexpected API response format:", data);
+                        }
+                    }
+                    catch (error) {
+                        console.error("Error fetching classification data:", error);
+                    }
+                }
+                if (field_ValidationMin)
+                    field.min = parseFloat(field_ValidationMin);
+                if (field_ValidationMax)
+                    field.max = parseFloat(field_ValidationMax);
+                if (field_Mask)
+                    field.pattern = field_Mask;
+                // Optional: Add any other fields you want to track, e.g. min, max, pattern (not clearly in your XML)
+                // You could also add the raw ControlType for round-trip fidelity if you want
+                schema.fields[field_ID] = field;
+            }
+            return schema;
+        }
+        catch (error) {
+            throw new Error(`XML to JSON conversion failed: ${error.message}`);
+        }
+    }
+    /**
+     * Convert JSON schema back to your new XML form definition format
+     */
+    static convertJsonToXml(jsonForm) {
+        try {
+            const doc = document.implementation.createDocument('', '', null);
+            const xforms = doc.createElement('Xforms');
+            Object.entries((jsonForm.schema ? jsonForm.schema : jsonForm.fields)).forEach(([fieldID, field]) => {
+                const fieldEl = doc.createElement('Fields');
+                const fieldToUse = field;
+                // Set all subelements based on your XML structure
+                // ID, PK IDs etc are missing here, so omit or generate dummy
+                // <SystemName>
+                const systemNameEl = doc.createElement('SystemName');
+                systemNameEl.textContent = fieldToUse.SystemName;
+                fieldEl.appendChild(systemNameEl);
+                // <LabelText>
+                const labelEl = doc.createElement('LabelText');
+                labelEl.textContent = fieldToUse.title || fieldID;
+                fieldEl.appendChild(labelEl);
+                // <HelpText>
+                const helpEl = doc.createElement('HelpText');
+                helpEl.textContent = fieldToUse.description;
+                fieldEl.appendChild(helpEl);
+                // <ControlType>
+                const controlTypeEl = doc.createElement('ControlType');
+                controlTypeEl.textContent = fieldToUse.realType;
+                fieldEl.appendChild(controlTypeEl);
+                // <ValidationRequired>
+                const validationEl = doc.createElement('ValidationRequired');
+                validationEl.textContent = fieldToUse.required ? 'Required' : 'Not Required';
+                fieldEl.appendChild(validationEl);
+                // <DefaultValue>
+                const defaultEl = doc.createElement('DefaultValue');
+                const valueEl = doc.createElement('Value');
+                if (jsonForm[fieldID] !== undefined) {
+                    defaultEl.textContent = jsonForm[fieldID].toString();
+                    valueEl.textContent = jsonForm[fieldID].toString();
+                }
+                else {
+                    defaultEl.textContent = fieldToUse.default || fieldToUse.value;
+                    valueEl.textContent = fieldToUse.value || fieldToUse.default;
+                }
+                fieldEl.appendChild(defaultEl);
+                fieldEl.appendChild(valueEl);
+                // <Enabled>
+                const enabledEl = doc.createElement('Enabled');
+                enabledEl.textContent = fieldToUse.Enabled === false ? 'False' : 'True';
+                fieldEl.appendChild(enabledEl);
+                // Add <isForm> Field to distinguish Field or Header etc
+                const isFormEl = doc.createElement('isForm');
+                isFormEl.textContent = fieldToUse.isForm;
+                fieldEl.appendChild(isFormEl);
+                if (fieldToUse.type === 'header') {
+                    const headerEl = doc.createElement('Header');
+                    headerEl.textContent = fieldToUse.title;
+                    fieldEl.appendChild(headerEl);
+                }
+                const idEl = doc.createElement('ID');
+                idEl.textContent = fieldToUse.ID;
+                fieldEl.appendChild(idEl);
+                const tfiePkIdEl = doc.createElement('TFie_PK_ID');
+                tfiePkIdEl.textContent = fieldToUse.TFie_PK_ID;
+                fieldEl.appendChild(tfiePkIdEl);
+                const tvalPkIdEl = doc.createElement('TVal_PK_ID');
+                tvalPkIdEl.textContent = fieldToUse.TVal_PK_ID;
+                fieldEl.appendChild(tvalPkIdEl);
+                const tfInPkIdEl = doc.createElement('TFIn_PK_ID');
+                tfInPkIdEl.textContent = fieldToUse.TFIn_PK_ID;
+                fieldEl.appendChild(tfInPkIdEl);
+                const cssStyleEl = doc.createElement('CssStyle');
+                cssStyleEl.textContent = fieldToUse.CssStyle;
+                fieldEl.appendChild(cssStyleEl);
+                const typeIdEl = doc.createElement('TypeId');
+                typeIdEl.textContent = fieldToUse.TypeId;
+                fieldEl.appendChild(typeIdEl);
+                const unitEl = doc.createElement('Unit');
+                unitEl.textContent = fieldToUse.Unit;
+                fieldEl.appendChild(unitEl);
+                const tfieFullPathEl = doc.createElement('TFie_Fullpath');
+                tfieFullPathEl.textContent = fieldToUse.TFie_Fullpath;
+                fieldEl.appendChild(tfieFullPathEl);
+                const tvalFkParentIdEl = doc.createElement('TVal_FK_Parent_ID');
+                tvalFkParentIdEl.textContent = fieldToUse.TVal_FK_Parent_ID;
+                fieldEl.appendChild(tvalFkParentIdEl);
+                const validationMinEl = doc.createElement('ValidationMin');
+                validationMinEl.textContent = fieldToUse.ValidationMin;
+                fieldEl.appendChild(validationMinEl);
+                const validationMaxEl = doc.createElement('ValidationMax');
+                validationMaxEl.textContent = fieldToUse.ValidationMax;
+                fieldEl.appendChild(validationMaxEl);
+                const maskEl = doc.createElement('Mask');
+                maskEl.textContent = fieldToUse.Mask;
+                fieldEl.appendChild(maskEl);
+                // Append to Xforms root
+                xforms.appendChild(fieldEl);
+            });
+            doc.appendChild(xforms);
+            const serializer = new XMLSerializer();
+            return serializer.serializeToString(doc);
+        }
+        catch (error) {
+            throw new Error(`JSON to XML conversion failed: ${error.message}`);
+        }
+    }
+    static mapControlTypeToJsonType(controlType) {
+        // Map your ControlType XML field to JSON field types
+        switch (controlType.toLowerCase()) {
+            case 'textbox':
+            case 'text':
+                return 'string';
+            case 'datepicker':
+                return 'date';
+            case 'thesauruspicker':
+            case 'thesauruspicker-ddl':
+            case 'termpicker':
+                return 'select';
+            case 'dbpicker':
+                return 'dbpicker'; // custom type if needed
+            case 'header':
+                return 'header'; // special type to handle header elements
+            case 'checkbox':
+                return 'boolean';
+            case 'realpicker':
+                return 'number';
+            default:
+                return 'string';
+        }
+    }
+}
+
+const voiceInputModuleCss = ":host{display:block;font-family:-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif}.voice-recorder-container{display:flex;flex-direction:column;align-items:center;gap:1rem;padding:1rem;border:1px solid #e5e7eb;border-radius:0.5rem;background:#ffffff;max-width:100px;margin:0 auto}.voice-recorder-container-debug{display:flex;flex-direction:column;align-items:center;gap:1rem;padding:1rem;border:1px solid #e5e7eb;border-radius:0.5rem;background:#ffffff;max-width:800px;margin:0 auto}.record-button{display:flex;align-items:center;justify-content:center;width:50px;height:50px;border:none;border-radius:50%;background:#ee4444;color:white;cursor:pointer;transition:all 0.2s ease;position:relative;overflow:hidden}.record-button:hover:not(:disabled){background:#dd3333;transform:scale(1.05)}.record-button:disabled{opacity:0.6;cursor:not-allowed}.record-button.recording{background:#dd3333;animation:pulse 1.5s infinite}.record-button.processing{background:#3b82f6}@keyframes pulse{0%{box-shadow:0 0 0 0 rgba(239, 68, 68, 0.7)}70%{box-shadow:0 0 0 10px rgba(239, 68, 68, 0)}100%{box-shadow:0 0 0 0 rgba(239, 68, 68, 0)}}.record-icon{width:24px;height:24px;fill:currentColor}.status-text{font-size:0.875rem;color:#6b7280;text-align:center;min-height:1.25rem}.status-text.error{color:#ee4444}.status-text.success{color:#10b981}.debug-panel{width:100%;margin-top:1rem;padding:1rem;background:#f9fafb;border:1px solid #e5e7eb;border-radius:0.375rem;font-family:'Monaco', 'Menlo', 'Ubuntu Mono', monospace;font-size:0.75rem}.debug-title{font-weight:600;margin-bottom:0.5rem;color:#374151}.debug-content{white-space:pre-wrap;word-break:break-word;color:#6b7280;max-height:200px;overflow-y:auto}.permissions-warning{padding:0.75rem;background:#fef3c7;border:1px solid #f59e0b;border-radius:0.375rem;color:#92400e;font-size:0.875rem;text-align:center}.form-preview{width:100%;margin-top:1rem;padding:1rem;background:#f8fafc;border:1px solid #e2e8f0;border-radius:0.375rem}.form-preview-title{font-weight:600;margin-bottom:0.5rem;color:#1e293b}.form-field{margin-bottom:0.5rem;font-size:0.875rem}.field-name{font-weight:500;color:#475569}.field-value{color:#64748b;margin-left:0.5rem}.field-value.filled{color:#059669;font-weight:500}.voice-filled-form{display:flex;flex-direction:column;gap:1rem;margin-top:1rem}.form-group{display:flex;flex-direction:column;gap:0.25rem}.form-label{font-weight:500;color:#374151;font-size:0.875rem}.required{color:#ee4444;margin-left:0.125rem}.form-input{padding:0.5rem;border:1px solid #d1d5db;border-radius:0.375rem;font-size:0.875rem;transition:border-color 0.2s ease}.form-input:focus{outline:none;border-color:#3b82f6;box-shadow:0 0 0 3px rgba(59, 130, 246, 0.1)}.form-checkbox{width:auto;padding:0;margin:0}select.form-input{background-color:white;cursor:pointer}input[type=\"date\"].form-input{cursor:pointer}.readonly-select{background:#f9fafb;border:1px solid #d1d5db;border-radius:0.375rem;padding:0.5rem}.select-placeholder{font-size:0.875rem;color:#6b7280;margin-bottom:0.5rem}.select-options-list{list-style:none;margin:0;padding:0;display:flex;flex-wrap:wrap;gap:0.25rem}.select-option{background:#e5e7eb;padding:0.25rem 0.5rem;border-radius:0.25rem;font-size:0.875rem;color:#374151}";
+
+const VoiceFormRecorder = /*@__PURE__*/ proxyCustomElement(class VoiceFormRecorder extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.__attachShadow();
+        this.formFilled = createEvent(this, "formFilled", 7);
+        this.recordingStateChanged = createEvent(this, "recordingStateChanged", 7);
+        this.formJson = '{}';
+        this.serviceConfig = '{}';
+        this.context = undefined;
+        this.classificationRootUrl = 'http://localhost';
+        this.language = 'en';
+        this.voiceOrOcr = undefined;
+        this.debug = false;
+        this.renderForm = false;
+        this.displayStatus = false;
+        this.isRecording = false;
+        this.isProcessing = false;
+        this.hasError = false;
+        this.transcription = '';
+        this.filledData = null;
+        this.debugInfo = {};
+        this.isReadonlyMode = true; // Start in readonly preview mode
+        this.audioRecorder = new AudioRecorderService();
+    }
+    componentWillLoad() {
+        this.initializeServices();
+    }
+    initializeServices() {
+        try {
+            if (!this.context) {
+                this.hasError = true;
+                const errorMessage = (this.language == 'en' ? `Initialization error: context is '${this.context}'` : `Erreur d'initialisation: le contexte est '${this.context}'`);
+                this.statusMessage = errorMessage;
+                this.updateDebugInfo(errorMessage, { error: errorMessage });
+            }
+            else {
+                // Parse form schema
+                this.parsedSchema = JSON.parse(this.formJson || '{}');
+                // Parse service configuration
+                this.parsedConfig = JSON.parse(this.serviceConfig || '{}');
+                // Add API key to config if provided via prop
+                if (this.apiKey) {
+                    this.parsedConfig = Object.assign(Object.assign({}, this.parsedConfig), { speechToText: Object.assign(Object.assign({}, this.parsedConfig.speechToText), { apiKey: this.apiKey }), llm: Object.assign(Object.assign({}, this.parsedConfig.llm), { apiKey: this.apiKey }) });
+                }
+                // Initialize services
+                this.speechToTextService = SpeechToTextServiceFactory.create(this.parsedConfig);
+                this.llmService = LLMServiceFactory.create(this.parsedConfig);
+                this.updateDebugInfo('Initialized', {
+                    schema: this.parsedSchema,
+                    config: this.parsedConfig
+                });
+                this.hasError = false;
+                this.statusMessage = (this.language == 'en' ? 'Click to start recording' : 'Cliquer pour enregistrer');
+            }
+        }
+        catch (error) {
+            this.hasError = true;
+            this.statusMessage = (this.language == 'en' ? `Initialization error: ${error.message}` : `Erreur d'initialisation: ${error.message}`);
+            this.updateDebugInfo('Initialization Error', { error: error.message });
+        }
+    }
+    updateDebugInfo(action, data) {
+        if (this.debug) {
+            this.debugInfo = Object.assign(Object.assign({}, this.debugInfo), { [action]: {
+                    timestamp: new Date().toISOString(),
+                    data
+                } });
+        }
+    }
+    async handleRecordClick() {
+        if (this.isProcessing)
+            return;
+        if (this.isRecording) {
+            await this.stopRecordingAndProcess();
+        }
+        else {
+            await this.startRecording();
+        }
+    }
+    async startRecording() {
+        try {
+            this.hasError = false;
+            this.statusMessage = (this.language == 'en' ? 'Starting recording...' : `Enregistrement ...`);
+            this.updateDebugInfo('Start Recording Attempt', {});
+            await this.audioRecorder.startRecording();
+            this.isRecording = true;
+            this.statusMessage = (this.language == 'en' ? 'Recording... Click to stop' : 'Enregistrement ... Cliquer pour stopper');
+            this.updateDebugInfo('Recording Started', {});
+            this.recordingStateChanged.emit({
+                isRecording: true,
+                state: 'recording'
+            });
+        }
+        catch (error) {
+            this.hasError = true;
+            this.statusMessage = (this.language == 'en' ? `Recording failed: ${error.message}` : `Echec de l'enregistrement : ${error.message}`);
+            this.updateDebugInfo('Recording Error', { error: error.message });
+            this.formFilled.emit({
+                success: false,
+                error: error.message
+            });
+        }
+    }
+    async processJsonForm(jsonForm) {
+        // console.log("processJsonForm", jsonForm);
+        try {
+            this.isProcessing = true;
+            this.statusMessage = (this.language == 'en' ? 'Processing json...' : `Traitement du json ...`);
+            // Fill form using LLM
+            this.statusMessage = (this.language == 'en' ? 'Filling form fields...' : 'Remplissage du formulaire ...');
+            const trimmedSchema = this.trimSchemaForAI(this.parsedSchema);
+            const filledSchema = await this.llmService.fillFormFromJson(jsonForm, trimmedSchema);
+            // Extract filled data
+            this.filledData = this.extractFilledData(filledSchema);
+            this.updateDebugInfo('Form Filled', {
+                filledSchema,
+                extractedData: this.filledData
+            });
+            this.parsedSchema = this.filledData;
+            this.statusMessage = (this.language == 'en' ? 'Form completed!' : 'Formulaire remplis !');
+            this.hasError = false;
+            // Emit success event
+            this.formFilled.emit({
+                success: true,
+                data: this.filledData,
+                jsonForm: jsonForm
+            });
+        }
+        catch (error) {
+            this.hasError = true;
+            this.statusMessage = (this.language == 'en' ? `Processing failed: ${error.message}` : `Erreur de traitement : ${error.message}`);
+            this.formFilled.emit({
+                success: false,
+                error: error.message,
+                jsonForm: jsonForm
+            });
+        }
+        finally {
+            this.isProcessing = false;
+        }
+    }
+    async stopRecordingAndProcess() {
+        try {
+            this.isRecording = false;
+            this.isProcessing = true;
+            this.statusMessage = (this.language == 'en' ? 'Processing audio...' : `Traitement de l'audio ...`);
+            this.updateDebugInfo('Stop Recording', {});
+            this.recordingStateChanged.emit({
+                isRecording: false,
+                state: 'processing'
+            });
+            // Stop recording and get audio blob
+            const audioBlob = await this.audioRecorder.stopRecording();
+            this.updateDebugInfo('Audio Captured', {
+                size: audioBlob.size,
+                type: audioBlob.type
+            });
+            // Transcribe audio
+            this.statusMessage = (this.language == 'en' ? 'Transcribing speech...' : 'Transcription du texte ...');
+            const transcription = await this.speechToTextService.transcribe(audioBlob, this.language);
+            this.transcription = transcription;
+            this.updateDebugInfo('Transcription Complete', { transcription });
+            if (!transcription.trim()) {
+                throw new Error('No speech detected in the recording');
+            }
+            // Fill form using LLM
+            this.statusMessage = (this.language == 'en' ? 'Filling form fields...' : 'Remplissage du formulaire ...');
+            const trimmedSchema = this.trimSchemaForAI(this.parsedSchema);
+            const filledSchema = await this.llmService.fillFormFromTranscription(transcription, trimmedSchema);
+            // Extract filled data
+            this.filledData = this.extractFilledData(filledSchema);
+            this.updateDebugInfo('Form Filled', {
+                filledSchema,
+                extractedData: this.filledData
+            });
+            this.parsedSchema = this.filledData;
+            this.statusMessage = (this.language == 'en' ? 'Form completed!' : 'Formulaire remplis !');
+            this.hasError = false;
+            // Emit success event
+            this.formFilled.emit({
+                success: true,
+                data: this.filledData,
+                transcription: transcription
+            });
+        }
+        catch (error) {
+            this.hasError = true;
+            this.statusMessage = (this.language == 'en' ? `Processing failed: ${error.message}` : `Erreur de traitement : ${error.message}`);
+            this.updateDebugInfo('Processing Error', { error: error.message });
+            this.formFilled.emit({
+                success: false,
+                error: error.message,
+                transcription: this.transcription
+            });
+        }
+        finally {
+            this.isProcessing = false;
+            this.recordingStateChanged.emit({
+                isRecording: false,
+                state: 'idle'
+            });
+        }
+    }
+    extractFilledData(filledData) {
+        // console.log("extractFilledData", filledData);
+        const updatedSchema = JSON.parse(JSON.stringify(this.parsedSchema));
+        switch (this.context) {
+            case "ng":
+                if (filledData === null || filledData === void 0 ? void 0 : filledData.fields) {
+                    // Map AI response back to original schema structure
+                    filledData.fields.forEach((field) => {
+                        const originalField = updatedSchema.Children.find((child) => child.System_Name === field.name);
+                        if (originalField && field.value !== undefined && field.value !== null && field.value !== '') {
+                            if (!originalField.Settings)
+                                originalField.Settings = {};
+                            originalField.Settings.Default_Value = field.value;
+                        }
+                    });
+                }
+                break;
+            case "ecoll-veto":
+                // console.log("TODO extractFilledData", filledData, updatedSchema);
+                if (filledData === null || filledData === void 0 ? void 0 : filledData.fields) {
+                    // Map AI response back to original schema structure
+                    filledData.fields.forEach((field) => {
+                        let originalField = updatedSchema[0].items.find((child) => child.label === field.name);
+                        if (!originalField)
+                            originalField = updatedSchema[1].items.find((child) => child.label === field.name);
+                        if (originalField && field.value !== undefined && field.value !== null && field.value !== '') {
+                            updatedSchema[2][originalField.name] = field.value;
+                        }
+                    });
+                }
+                break;
+            case "ecoteka":
+                // console.log("TODO extractFilledData", filledData);
+                break;
+            case "track":
+            default:
+                Object.entries(filledData.fields).forEach(([fieldID, field]) => {
+                    if (field.default !== undefined && field.default !== null && field.default !== '') {
+                        updatedSchema[fieldID] = field.default;
+                    }
+                    if (field.value !== undefined && field.value !== null && field.value !== '') {
+                        for (const key in updatedSchema.fields) {
+                            const schemaField = updatedSchema.fields[key];
+                            if (schemaField.title === field.name) {
+                                schemaField.value = field.value || field.default;
+                                schemaField.default = field.value || field.default;
+                                break; // stop after finding the first match
+                            }
+                        }
+                    }
+                });
+                break;
+        }
+        // console.log("extractFilledData result", updatedSchema);
+        return updatedSchema;
+    }
+    trimSchemaForAI(schema) {
+        var _a, _b;
+        // console.log("trimSchemaForAI", schema);
+        switch (this.context) {
+            case 'ng':
+                const trimmed = { fields: [] };
+                schema.Children.forEach((child) => {
+                    if (!child.System_Name || !child.Type)
+                        return;
+                    const fieldData = {
+                        name: child.System_Name,
+                        type: this.mapFieldType(child.Type)
+                    };
+                    // Add options for classification/select fields
+                    if (child.Type === 'InputClassification' && child.Children && child.Children.length > 0) {
+                        fieldData.options = child.Children.map((option) => option.System_Name || option.Label || option.toString());
+                    }
+                    trimmed.fields.push(fieldData);
+                });
+                // console.log("Schema apres transformation, contexte NG:", trimmed);
+                return trimmed;
+            case 'ecoll-veto':
+                // console.log("TODO trimSchemaForAI", schema)
+                const mergedItemsSchema = (this.parsedSchema[0].items).concat(this.parsedSchema[1].items);
+                if (mergedItemsSchema) {
+                    const trimmedSchema = {
+                        title: 'Form Name',
+                        description: 'Form Description',
+                        schema: {}
+                    };
+                    Object.entries(mergedItemsSchema).forEach(([key, field]) => {
+                        const fieldName = field.name;
+                        const fieldType = this.mapFieldType(field.type);
+                        const fieldLabel = field.label || fieldName;
+                        trimmedSchema.schema[fieldName] = {
+                            type: fieldType,
+                            title: fieldLabel,
+                            options: field.options,
+                            readonly: field.readonly === true,
+                            default: '',
+                        };
+                    });
+                    // console.log("Schema apres transformation, contexte Track:", trimmedSchema);
+                    return trimmedSchema;
+                }
+            case "ecoteka":
+                // console.log("TODO trimSchemaForAI", schema)
+                break;
+            case 'track':
+            default:
+                // Handle simple schema format (backward compatibility)
+                if ((_a = schema === null || schema === void 0 ? void 0 : schema.schema) !== null && _a !== void 0 ? _a : schema === null || schema === void 0 ? void 0 : schema.fields) {
+                    const trimmedSchema = {
+                        title: schema.title,
+                        description: schema.description,
+                        schema: {}
+                    };
+                    const finalSchema = (_b = schema === null || schema === void 0 ? void 0 : schema.schema) !== null && _b !== void 0 ? _b : schema === null || schema === void 0 ? void 0 : schema.fields;
+                    Object.entries(finalSchema).forEach(([fieldName, field]) => {
+                        trimmedSchema.schema[fieldName] = {
+                            type: field.type,
+                            title: field.title,
+                            options: field.options,
+                            readonly: field.Enabled === false,
+                            default: field.DefaultValue,
+                            pattern: field.Mask,
+                            min: field.ValidationMin,
+                            max: field.ValidationMax
+                        };
+                    });
+                    // console.log("Schema apres transformation, contexte Track:", trimmedSchema);
+                    return trimmedSchema;
+                }
+                break;
+        }
+        return schema;
+    }
+    mapFieldType(type) {
+        const typeMapping = {
+            'InputAutocomplete': 'string',
+            'InputInteger': 'number',
+            'InputTextArea': 'string',
+            'InputDateTimePicker': 'datetime',
+            'InputDecimal': 'number',
+            'InputClassification': 'select',
+            'InputCheckbox': 'boolean',
+            'InputTextTranslation': 'string',
+            'thesaurus': 'string',
+            'position': 'string',
+            'text': 'string',
+            'textarea': 'string',
+            'number': 'number',
+            'date': 'date',
+            'datetime': 'datetime'
+        };
+        return typeMapping[type] || 'string';
+    }
+    // Utility methods exposed as public API
+    async convertXmlToJson(xmlForm) {
+        return SchemaConverter.convertXmlToJson(xmlForm, this.classificationRootUrl, this.language);
+    }
+    async convertJsonToXml(jsonForm) {
+        return SchemaConverter.convertJsonToXml(jsonForm);
+    }
+    // Utility methods exposed as public API
+    async convertXmlToJsonLegacy(xmlForm) {
+        return SchemaConverter.convertXmlToJsonLegacy(xmlForm);
+    }
+    async convertJsonToXmlLegacy(jsonForm) {
+        return SchemaConverter.convertJsonToXmlLegacy(jsonForm);
+    }
+    renderUploadButton() {
+        if (!['ocr', 'both'].includes(this.voiceOrOcr))
+            return;
+        return (h("file-uploader", { batch: false, callback: (data) => { this.processJsonForm(data); } }));
+    }
+    renderRecordButton() {
+        if (!['voice', 'both', undefined].includes(this.voiceOrOcr))
+            return;
+        const buttonClass = [
+            'record-button',
+            this.isRecording && 'recording',
+            this.isProcessing && 'processing'
+        ].filter(Boolean).join(' ');
+        const isDisabled = this.isProcessing || this.hasError;
+        return (h("button", { class: buttonClass, onClick: () => this.handleRecordClick(), disabled: isDisabled, "aria-label": this.isRecording ? 'Stop recording' : 'Start recording' }, this.isProcessing ? (h("svg", { class: "record-icon", viewBox: "0 0 24 24" }, h("circle", { cx: "12", cy: "12", r: "3" }, h("animate", { attributeName: "r", values: "3;6;3", dur: "1s", repeatCount: "indefinite" }), h("animate", { attributeName: "opacity", values: "1;0.3;1", dur: "1s", repeatCount: "indefinite" })))) : this.isRecording ? (h("svg", { class: "record-icon", viewBox: "0 0 24 24" }, h("rect", { x: "6", y: "6", width: "12", height: "12", rx: "2" }))) : (h("svg", { class: "record-icon", viewBox: "0 0 24 24" }, h("circle", { cx: "12", cy: "12", r: "8" })))));
+    }
+    renderStatusMessage() {
+        const statusClass = [
+            'status-text',
+            this.hasError && 'error',
+            this.filledData && !this.hasError && 'success'
+        ].filter(Boolean).join(' ');
+        return h("div", { class: statusClass }, this.statusMessage);
+    }
+    renderFormPreview() {
+        if (!this.parsedSchema)
+            return null;
+        const isPreview = this.isReadonlyMode && !this.filledData;
+        const title = isPreview ? 'Form Preview (Voice input to fill)' : 'Voice-Filled Form:';
+        return (h("div", { class: "form-preview" }, h("div", { class: "form-preview-title" }, title), h("form", { class: "voice-filled-form" }, this.renderFormFields())));
+    }
+    renderFormFields() {
+        // console.log("renderFormFields", this.parsedSchema);
+        if (!this.parsedSchema)
+            return null;
+        switch (this.context) {
+            case "ng":
+                return this.parsedSchema.Children.map((child) => {
+                    var _a, _b, _c;
+                    if (!child.System_Name || !child.Type)
+                        return null;
+                    const fieldName = child.System_Name;
+                    const fieldType = this.mapFieldType(child.Type);
+                    const fieldLabel = ((_a = child.Settings) === null || _a === void 0 ? void 0 : _a.Label) || child.System_Name;
+                    const isRequired = child.Required || false;
+                    const fieldValue = (_b = child.Settings) === null || _b === void 0 ? void 0 : _b.Default_Value;
+                    return (h("div", { class: "form-group", key: fieldName }, h("label", { htmlFor: fieldName, class: "form-label" }, fieldLabel, isRequired && h("span", { class: "required" }, "*")), this.renderFormField(fieldName, {
+                        type: fieldType,
+                        title: fieldLabel,
+                        required: isRequired,
+                        options: (_c = child.Children) === null || _c === void 0 ? void 0 : _c.map((option) => option.System_Name || option.Label || option.toString())
+                    }, fieldValue)));
+                }).filter(Boolean);
+            case "ecoll-veto":
+                // NOTE STEP 2
+                // console.log("TODO renderFormFields", this.parsedSchema);
+                const mergedItemsSchema = (this.parsedSchema[0].items).concat(this.parsedSchema[1].items);
+                return Object.entries(mergedItemsSchema).map(([key, field]) => {
+                    var _a, _b;
+                    const fieldName = field.name;
+                    field.type = this.mapFieldType(field.type);
+                    const fieldLabel = field.label || fieldName;
+                    const isRequired = field.required || false;
+                    const fieldValue = this.parsedSchema[2][fieldName];
+                    return (h("div", { class: "form-group", key: fieldName }, h("label", { htmlFor: fieldName, class: "form-label" }, fieldLabel, isRequired && h("span", { class: "required" }, "*")), this.renderFormField(fieldName, field, ((_b = (_a = this.filledData) === null || _a === void 0 ? void 0 : _a[fieldName]) !== null && _b !== void 0 ? _b : fieldValue))));
+                });
+            case "ecoteka":
+                // console.log("TODO renderFormFields", this.parsedSchema);
+                break;
+            case "track":
+            default:
+                return Object.entries(this.parsedSchema.fields).map(([fieldName, field]) => {
+                    var _a, _b;
+                    return (h("div", { class: "form-group", key: fieldName }, h("label", { htmlFor: fieldName, class: "form-label" }, field.title || fieldName, field.required && h("span", { class: "required" }, "*")), this.renderFormField(fieldName, field, ((_b = (_a = this.filledData) === null || _a === void 0 ? void 0 : _a[fieldName]) !== null && _b !== void 0 ? _b : field.value))));
+                });
+        }
+        return null;
+    }
+    renderFormField(fieldName, field, value) {
+        var _a, _b;
+        const isReadonly = this.isReadonlyMode && !this.filledData;
+        const commonProps = {
+            id: fieldName,
+            name: fieldName,
+            class: 'form-input',
+            required: field.required,
+            disabled: isReadonly
+        };
+        switch (field.type) {
+            case 'select':
+                if (isReadonly) {
+                    // In readonly mode, show all options as a list instead of dropdown
+                    return (h("div", { class: "readonly-select" }, h("div", { class: "select-placeholder" }, "Available options:"), h("ul", { class: "select-options-list" }, (_a = field.options) === null || _a === void 0 ? void 0 : _a.map(option => (h("li", { class: "select-option" }, option))))));
+                }
+                return (h("select", { id: fieldName, name: fieldName, class: "form-input", required: field.required }, h("option", { value: "" }, "-- Select --"), (_b = field.options) === null || _b === void 0 ? void 0 :
+                    _b.map(option => (h("option", { value: option, selected: value === option }, option)))));
+            case 'boolean':
+                return (h("input", Object.assign({}, commonProps, { type: "checkbox", class: "form-checkbox", checked: value === true || value === 'true' })));
+            case 'number':
+                return (h("input", Object.assign({}, commonProps, { type: "number", min: field.min, max: field.max, step: "any", value: value || '' })));
+            case 'date':
+                return (h("input", Object.assign({}, commonProps, { type: 'date', value: value ? (([d, m, y]) => `${y}-${m}-${d}`)(value.split("/")) : '' })));
+            case 'datetime':
+                return (h("input", Object.assign({}, commonProps, { type: 'datetime-local', value: value || '' })));
+            default: // string
+                return (h("input", Object.assign({}, commonProps, { type: "text", pattern: field.pattern, placeholder: field.description, value: value || '' })));
+        }
+    }
+    renderDebugPanel() {
+        if (!this.debug)
+            return null;
+        return (h("div", { class: "debug-panel" }, h("div", { class: "debug-title" }, "Debug Information:"), h("div", { class: "debug-content" }, JSON.stringify(this.debugInfo, null, 2))));
+    }
+    render() {
+        return (h("div", { key: '40d850c62945b71d22c1fcb6181c9e8aba0f2a05' }, h("div", { key: 'da8aa5b7f122471a8d4d49662d418bd925f1d84c', class: "voice-recorder-container" + (this.debug || this.renderForm ? "-debug" : "") }, this.renderRecordButton(), this.displayStatus ? this.renderStatusMessage() : "", this.renderUploadButton(), this.renderForm ? this.renderFormPreview() : "", this.debug ? this.renderDebugPanel() : "")));
+    }
+    static get watchers() { return {
+        "formJson": ["initializeServices"],
+        "serviceConfig": ["initializeServices"]
+    }; }
+    static get style() { return voiceInputModuleCss; }
+}, [257, "voice-input-module", {
+        "formJson": [1, "form-json"],
+        "serviceConfig": [1, "service-config"],
+        "apiKey": [1, "api-key"],
+        "context": [1],
+        "classificationRootUrl": [1, "classification-root-url"],
+        "language": [1],
+        "voiceOrOcr": [1, "voice-or-ocr"],
+        "debug": [4],
+        "renderForm": [4, "render-form"],
+        "displayStatus": [4, "display-status"],
+        "isRecording": [32],
+        "isProcessing": [32],
+        "statusMessage": [32],
+        "hasError": [32],
+        "transcription": [32],
+        "filledData": [32],
+        "debugInfo": [32],
+        "isReadonlyMode": [32],
+        "convertXmlToJson": [64],
+        "convertJsonToXml": [64],
+        "convertXmlToJsonLegacy": [64],
+        "convertJsonToXmlLegacy": [64]
+    }, undefined, {
+        "formJson": ["initializeServices"],
+        "serviceConfig": ["initializeServices"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["voice-input-module", "file-uploader"];
+    components.forEach(tagName => { switch (tagName) {
+        case "voice-input-module":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, VoiceFormRecorder);
+            }
+            break;
+        case "file-uploader":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$2();
+            }
+            break;
+    } });
+}
+
+const VoiceInputModule = VoiceFormRecorder;
+const defineCustomElement = defineCustomElement$1;
+
+export { VoiceInputModule, defineCustomElement };
+//# sourceMappingURL=voice-input-module.js.map
+
+//# sourceMappingURL=voice-input-module.js.map