reneco-advanced-input-module 0.0.1

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

@@ -0,0 +1,875 @@
+import { h } from "@stencil/core";
+import { AudioRecorderService } from "../../services/audio-recorder.service";
+import { SpeechToTextServiceFactory } from "../../services/speech-to-text.service";
+import { LLMServiceFactory } from "../../services/llm.service";
+import { SchemaConverter } from "../../utils/schema-converter";
+export class VoiceFormRecorder {
+    constructor() {
+        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:
+                const data = {};
+                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;
+                        const isRequired = field.required || false;
+                        const fieldValue = ''; //TODO
+                        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 is() { return "voice-input-module"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["voice-input-module.css"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["voice-input-module.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "formJson": {
+                "type": "string",
+                "attribute": "form-json",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "'{}'"
+            },
+            "serviceConfig": {
+                "type": "string",
+                "attribute": "service-config",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "'{}'"
+            },
+            "apiKey": {
+                "type": "string",
+                "attribute": "api-key",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false
+            },
+            "context": {
+                "type": "string",
+                "attribute": "context",
+                "mutable": false,
+                "complexType": {
+                    "original": "'track'|'ng'|'ecoll-veto'|'ecoteka'",
+                    "resolved": "\"ecoll-veto\" | \"ecoteka\" | \"ng\" | \"track\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "undefined"
+            },
+            "classificationRootUrl": {
+                "type": "string",
+                "attribute": "classification-root-url",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "'http://localhost'"
+            },
+            "language": {
+                "type": "string",
+                "attribute": "language",
+                "mutable": false,
+                "complexType": {
+                    "original": "'fr'|'en'",
+                    "resolved": "\"en\" | \"fr\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "'en'"
+            },
+            "voiceOrOcr": {
+                "type": "string",
+                "attribute": "voice-or-ocr",
+                "mutable": false,
+                "complexType": {
+                    "original": "'voice'|'ocr'|'both'",
+                    "resolved": "\"both\" | \"ocr\" | \"voice\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "undefined"
+            },
+            "debug": {
+                "type": "boolean",
+                "attribute": "debug",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "renderForm": {
+                "type": "boolean",
+                "attribute": "render-form",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "displayStatus": {
+                "type": "boolean",
+                "attribute": "display-status",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "defaultValue": "false"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "isRecording": {},
+            "isProcessing": {},
+            "statusMessage": {},
+            "hasError": {},
+            "transcription": {},
+            "filledData": {},
+            "debugInfo": {},
+            "isReadonlyMode": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "formFilled",
+                "name": "formFilled",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "VoiceFormRecorderResult",
+                    "resolved": "VoiceFormRecorderResult",
+                    "references": {
+                        "VoiceFormRecorderResult": {
+                            "location": "import",
+                            "path": "../../types/form-schema.types",
+                            "id": "src/types/form-schema.types.ts::VoiceFormRecorderResult"
+                        }
+                    }
+                }
+            }, {
+                "method": "recordingStateChanged",
+                "name": "recordingStateChanged",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "{ isRecording: boolean; state: string }",
+                    "resolved": "{ isRecording: boolean; state: string; }",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "convertXmlToJson": {
+                "complexType": {
+                    "signature": "(xmlForm: string) => Promise<FormSchemaFieldsOnly>",
+                    "parameters": [{
+                            "name": "xmlForm",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "FormSchemaFieldsOnly": {
+                            "location": "import",
+                            "path": "../../types/form-schema.types",
+                            "id": "src/types/form-schema.types.ts::FormSchemaFieldsOnly"
+                        }
+                    },
+                    "return": "Promise<FormSchemaFieldsOnly>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "convertJsonToXml": {
+                "complexType": {
+                    "signature": "(jsonForm: FormSchemaFieldsOnlyExtended) => Promise<string>",
+                    "parameters": [{
+                            "name": "jsonForm",
+                            "type": "FormSchemaFieldsOnlyExtended",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "FormSchemaFieldsOnlyExtended": {
+                            "location": "import",
+                            "path": "../../types/form-schema.types",
+                            "id": "src/types/form-schema.types.ts::FormSchemaFieldsOnlyExtended"
+                        }
+                    },
+                    "return": "Promise<string>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "convertXmlToJsonLegacy": {
+                "complexType": {
+                    "signature": "(xmlForm: string) => Promise<FormSchema>",
+                    "parameters": [{
+                            "name": "xmlForm",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "FormSchema": {
+                            "location": "import",
+                            "path": "../../types/form-schema.types",
+                            "id": "src/types/form-schema.types.ts::FormSchema"
+                        }
+                    },
+                    "return": "Promise<FormSchema>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "convertJsonToXmlLegacy": {
+                "complexType": {
+                    "signature": "(jsonForm: FormSchema) => Promise<string>",
+                    "parameters": [{
+                            "name": "jsonForm",
+                            "type": "FormSchema",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "FormSchema": {
+                            "location": "import",
+                            "path": "../../types/form-schema.types",
+                            "id": "src/types/form-schema.types.ts::FormSchema"
+                        }
+                    },
+                    "return": "Promise<string>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get watchers() {
+        return [{
+                "propName": "formJson",
+                "methodName": "initializeServices"
+            }, {
+                "propName": "serviceConfig",
+                "methodName": "initializeServices"
+            }];
+    }
+}
+//# sourceMappingURL=voice-input-module.js.map