@esheet/adapters 0.0.3 → 0.0.4-1

package/README.md

@@ -1 +1 @@
-# Adapter Pakcage
+# Adapter Package

package/dist/fhir/fhir-adapter.d.ts

@@ -0,0 +1,21 @@
+import type { FormDefinition } from '@esheet/core';
+import type { FhirQuestionnaire, FhirQuestionnaireResponse, FhirImportOptions, FhirExportOptions, ResponseImportOptions, ResponseExportOptions } from './types.js';
+import { isFhirQuestionnaire, isFhirQuestionnaireResponse } from './utils.js';
+export { isFhirQuestionnaire, isFhirQuestionnaireResponse };
+/**
+ * Convert a FHIR R4 Questionnaire to an eSheet FormDefinition.
+ */
+export declare function importFromFhir(questionnaire: FhirQuestionnaire, options?: FhirImportOptions): FormDefinition;
+/**
+ * Convert an eSheet FormDefinition to a FHIR R4 Questionnaire.
+ */
+export declare function exportToFhir(form: FormDefinition, options?: FhirExportOptions): FhirQuestionnaire;
+/**
+ * Convert a FHIR QuestionnaireResponse to an eSheet answer map.
+ */
+export declare function importResponseFromFhir(response: FhirQuestionnaireResponse, options?: ResponseImportOptions): Record<string, unknown>;
+/**
+ * Convert eSheet answers to a FHIR QuestionnaireResponse.
+ */
+export declare function exportResponseToFhir(form: FormDefinition, answers: Record<string, unknown>, options: ResponseExportOptions): FhirQuestionnaireResponse;
+//# sourceMappingURL=fhir-adapter.d.ts.map

package/dist/fhir/fhir-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fhir-adapter.d.ts","sourceRoot":"","sources":["../../src/fhir/fhir-adapter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,cAAc,EAOf,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EACV,iBAAiB,EAEjB,yBAAyB,EAMzB,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EAKtB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,mBAAmB,EACnB,2BAA2B,EAc5B,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,CAAC;AAM5D;;GAEG;AACH,wBAAgB,cAAc,CAC5B,aAAa,EAAE,iBAAiB,EAChC,OAAO,CAAC,EAAE,iBAAiB,GAC1B,cAAc,CA0BhB;AAiSD;;GAEG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,cAAc,EACpB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,iBAAiB,CAmCnB;AAsID;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,yBAAyB,EACnC,OAAO,CAAC,EAAE,qBAAqB,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQzB;AAuDD;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,OAAO,EAAE,qBAAqB,GAC7B,yBAAyB,CAa3B"}

package/dist/fhir/fhir-adapter.js

@@ -0,0 +1,564 @@
+// ---------------------------------------------------------------------------
+// FHIR R4 Adapter - Bidirectional conversion
+// ---------------------------------------------------------------------------
+import { isFhirQuestionnaire, isFhirQuestionnaireResponse, mapFhirTypeToEsheet, mapEsheetTypeToFhir, convertAnswerOptionToFieldOption, convertOptionToFhirAnswerOption, mapFhirOperatorToEsheet, mapEsheetOperatorToFhir, mapEnableBehaviorToLogic, extractEnableWhenAnswer, getExtensionValue, createItemControlExtension, createSignatureRequiredExtension, generateUUID, FHIR_EXT, } from './utils.js';
+// Re-export type guards
+export { isFhirQuestionnaire, isFhirQuestionnaireResponse };
+// ---------------------------------------------------------------------------
+// Import: FHIR Questionnaire → FormDefinition
+// ---------------------------------------------------------------------------
+/**
+ * Convert a FHIR R4 Questionnaire to an eSheet FormDefinition.
+ */
+export function importFromFhir(questionnaire, options) {
+    const warnings = [];
+    const formId = options?.formId ?? questionnaire.id ?? questionnaire.name ?? generateUUID();
+    const form = {
+        id: formId,
+        title: questionnaire.title,
+        description: questionnaire.description,
+        fields: [],
+        _sourceData: extractFormMetadata(questionnaire, options),
+    };
+    if (questionnaire.item) {
+        form.fields = questionnaire.item.map((item, index) => convertItemToField(item, `item[${index}]`, warnings, options));
+    }
+    if (warnings.length > 0) {
+        const meta = form._sourceData;
+        meta._conversionWarnings =
+            warnings;
+    }
+    return form;
+}
+function extractFormMetadata(q, options) {
+    const meta = {};
+    const preserve = options?.preserveExtensions !== false;
+    if (q.url)
+        meta.url = q.url;
+    if (q.version)
+        meta.version = q.version;
+    if (q.name)
+        meta.name = q.name;
+    if (q.status)
+        meta.status = q.status;
+    if (q.publisher)
+        meta.publisher = q.publisher;
+    if (q.date)
+        meta.date = q.date;
+    if (q.subjectType)
+        meta.subjectType = q.subjectType;
+    if (q.derivedFrom)
+        meta.derivedFrom = q.derivedFrom;
+    if (q.code)
+        meta.code = q.code;
+    if (preserve && q.extension) {
+        meta.fhirExtensions =
+            q.extension;
+    }
+    return meta;
+}
+function convertItemToField(item, path, warnings, options) {
+    const typeResult = mapFhirTypeToEsheet(item.type, item);
+    const existingIds = new Set();
+    // Build base field
+    const base = {
+        id: item.linkId,
+        question: item.text,
+        required: item.required,
+    };
+    // Build _sourceData for round-trip
+    const fieldMeta = buildFieldMeta(item, typeResult, options);
+    const hasFieldMeta = Object.keys(fieldMeta).length > 0;
+    // Convert enableWhen to rules
+    const rules = convertEnableWhenToRules(item.enableWhen, item.enableBehavior);
+    const rulesSpread = rules.length > 0 ? { rules } : {};
+    // Handle warnings for lossy conversions
+    addConversionWarnings(item, path, typeResult, warnings);
+    // Build field based on type
+    switch (typeResult.fieldType) {
+        case 'section':
+            return buildSectionField(base, item, path, warnings, options, hasFieldMeta ? fieldMeta : undefined);
+        case 'radio':
+        case 'check':
+        case 'dropdown':
+        case 'multiselectdropdown':
+            return {
+                ...base,
+                ...(hasFieldMeta ? { _sourceData: fieldMeta } : {}),
+                ...rulesSpread,
+                fieldType: typeResult.fieldType,
+                options: convertAnswerOptions(item.answerOption, existingIds),
+            };
+        case 'rating':
+        case 'slider':
+            return {
+                ...base,
+                ...(hasFieldMeta ? { _sourceData: fieldMeta } : {}),
+                ...rulesSpread,
+                fieldType: typeResult.fieldType,
+                options: convertAnswerOptions(item.answerOption, existingIds),
+            };
+        case 'text':
+        case 'longtext':
+            return {
+                ...base,
+                ...(hasFieldMeta ? { _sourceData: fieldMeta } : {}),
+                ...rulesSpread,
+                fieldType: typeResult.fieldType,
+                ...(typeResult.inputType ? { inputType: typeResult.inputType } : {}),
+            };
+        case 'display':
+            // Display fields have no question — FHIR item.text maps to content (the displayed text)
+            return {
+                id: base.id,
+                ...(hasFieldMeta ? { _sourceData: fieldMeta } : {}),
+                ...rulesSpread,
+                fieldType: 'display',
+                content: item.text,
+            };
+        case 'boolean':
+        case 'signature':
+        case 'diagram':
+            return {
+                ...base,
+                ...(hasFieldMeta ? { _sourceData: fieldMeta } : {}),
+                ...rulesSpread,
+                fieldType: typeResult.fieldType,
+            };
+        default:
+            return {
+                ...base,
+                ...(hasFieldMeta ? { _sourceData: fieldMeta } : {}),
+                ...rulesSpread,
+                fieldType: 'text',
+            };
+    }
+}
+function buildSectionField(base, item, path, warnings, options, fieldMeta) {
+    const nestedFields = item.item
+        ? item.item.map((child, i) => convertItemToField(child, `${path}.item[${i}]`, warnings, options))
+        : [];
+    return {
+        ...base,
+        ...(fieldMeta ? { _sourceData: fieldMeta } : {}),
+        fieldType: 'section',
+        title: item.text,
+        fields: nestedFields,
+    };
+}
+function buildFieldMeta(item, typeResult, options) {
+    const meta = {};
+    const preserve = options?.preserveExtensions !== false;
+    if (item.definition)
+        meta.definition = item.definition;
+    if (item.code)
+        meta.code = item.code;
+    if (item.prefix)
+        meta.prefix = item.prefix;
+    if (item.readOnly)
+        meta.readOnly = item.readOnly;
+    if (item.repeats)
+        meta.repeats = item.repeats;
+    // Store original FHIR type for export
+    meta.fhirItemType = item.type;
+    // Extract validation extensions
+    const minVal = getExtensionValue(item.extension, FHIR_EXT.MIN_VALUE);
+    const maxVal = getExtensionValue(item.extension, FHIR_EXT.MAX_VALUE);
+    const minLen = getExtensionValue(item.extension, FHIR_EXT.MIN_LENGTH);
+    const regex = getExtensionValue(item.extension, FHIR_EXT.REGEX);
+    if (minVal !== undefined)
+        meta.minValue = minVal;
+    if (maxVal !== undefined)
+        meta.maxValue = maxVal;
+    if (minLen !== undefined)
+        meta.minLength = minLen;
+    if (regex !== undefined)
+        meta.regex = regex;
+    // Preserve unknown extensions
+    if (preserve && item.extension) {
+        meta.fhirExtensions =
+            item.extension;
+    }
+    // Preserve answerValueSet URL for client-side resolution
+    if (item.answerValueSet) {
+        meta.answerValueSet = item.answerValueSet;
+    }
+    return meta;
+}
+function convertAnswerOptions(answerOptions, existingIds) {
+    if (!answerOptions)
+        return [];
+    return answerOptions.map((opt, index) => convertAnswerOptionToFieldOption(opt, existingIds, index));
+}
+function convertEnableWhenToRules(enableWhen, enableBehavior) {
+    if (!enableWhen || enableWhen.length === 0)
+        return [];
+    const conditions = [];
+    for (const ew of enableWhen) {
+        const operator = mapFhirOperatorToEsheet(ew.operator, ew.answerBoolean);
+        if (!operator)
+            continue;
+        conditions.push({
+            conditionType: 'field',
+            targetId: ew.question,
+            operator,
+            expected: extractEnableWhenAnswer(ew),
+        });
+    }
+    if (conditions.length === 0)
+        return [];
+    return [
+        {
+            effect: 'visible',
+            logic: mapEnableBehaviorToLogic(enableBehavior),
+            conditions,
+        },
+    ];
+}
+function addConversionWarnings(item, path, typeResult, warnings) {
+    // Reference type warning
+    if (typeResult.subType === 'reference') {
+        warnings.push({
+            path,
+            code: 'UNSUPPORTED_TYPE',
+            message: `FHIR reference type converted to text field. Type safety lost.`,
+        });
+    }
+    // Quantity type warning
+    if (typeResult.subType === 'quantity') {
+        warnings.push({
+            path,
+            code: 'UNSUPPORTED_TYPE',
+            message: `FHIR quantity type converted to number field. Unit choices lost.`,
+        });
+    }
+    // ValueSet reference (informational)
+    if (item.answerValueSet) {
+        warnings.push({
+            path,
+            code: 'VALUESET_NOT_EXPANDED',
+            severity: 'info',
+            message: `ValueSet "${item.answerValueSet}" requires expansion. URL preserved in _sourceData.answerValueSet for client-side $expand.`,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Export: FormDefinition → FHIR Questionnaire
+// ---------------------------------------------------------------------------
+/**
+ * Convert an eSheet FormDefinition to a FHIR R4 Questionnaire.
+ */
+export function exportToFhir(form, options) {
+    const sourceMeta = form._sourceData;
+    const questionnaire = {
+        resourceType: 'Questionnaire',
+        id: options?.resourceId ?? form.id,
+        url: options?.canonicalUrl
+            ? `${options.canonicalUrl}/Questionnaire/${form.id}`
+            : sourceMeta?.url ?? `urn:uuid:${generateUUID()}`,
+        status: options?.status ?? sourceMeta?.status ?? 'draft',
+        title: form.title,
+        description: form.description,
+        ...(sourceMeta?.version ? { version: sourceMeta.version } : {}),
+        ...(options?.publisher ?? sourceMeta?.publisher
+            ? { publisher: options?.publisher ?? sourceMeta?.publisher }
+            : {}),
+        ...(sourceMeta?.date ? { date: sourceMeta.date } : {}),
+        item: form.fields.map(convertFieldToItem),
+    };
+    // DTR compliance
+    if (options?.dtrCompliant) {
+        questionnaire.subjectType = [
+            'Patient',
+        ];
+    }
+    // Restore preserved extensions
+    if (sourceMeta?.fhirExtensions) {
+        questionnaire.extension = sourceMeta.fhirExtensions;
+    }
+    return questionnaire;
+}
+function convertFieldToItem(field) {
+    const fieldMeta = field._sourceData;
+    const inputType = 'inputType' in field ? field.inputType : undefined;
+    const typeResult = mapEsheetTypeToFhir(field.fieldType, inputType);
+    // For sections, use title if question is not set
+    const text = field.question ??
+        (field.fieldType === 'section' && 'title' in field
+            ? field.title
+            : undefined);
+    const item = {
+        linkId: field.id,
+        text,
+        type: typeResult.type,
+        ...(field.required ? { required: true } : {}),
+        ...(typeResult.repeats ? { repeats: true } : {}),
+        ...(fieldMeta?.readOnly ? { readOnly: true } : {}),
+    };
+    // Build extensions array
+    const extensions = [];
+    // Add itemControl extension
+    if (typeResult.itemControl) {
+        extensions.push(createItemControlExtension(typeResult.itemControl));
+    }
+    // Add signature extension for signature fields
+    if (field.fieldType === 'signature') {
+        extensions.push(createSignatureRequiredExtension());
+    }
+    // Add preserved extensions
+    if (fieldMeta?.fhirExtensions) {
+        // Filter out extensions we're generating ourselves
+        const preserved = fieldMeta.fhirExtensions.filter((e) => e.url !== FHIR_EXT.ITEM_CONTROL && e.url !== FHIR_EXT.SIGNATURE_REQUIRED);
+        extensions.push(...preserved);
+    }
+    if (extensions.length > 0) {
+        item.extension = extensions;
+    }
+    // Add answer options
+    if ('options' in field && field.options && field.options.length > 0) {
+        item.answerOption =
+            field.options.map(convertOptionToFhirAnswerOption);
+    }
+    // Add enableWhen for visibility rules
+    const enableWhen = convertRulesToEnableWhen(field.rules);
+    if (enableWhen.length > 0) {
+        item.enableWhen =
+            enableWhen;
+        if (enableWhen.length > 1) {
+            // Check original logic mode
+            const visibleRule = field.rules?.find((r) => r.effect === 'visible');
+            item.enableBehavior =
+                visibleRule?.logic === 'OR' ? 'any' : 'all';
+        }
+    }
+    // Handle nested fields for sections
+    if (field.fieldType === 'section' && 'fields' in field && field.fields) {
+        item.item =
+            field.fields.map(convertFieldToItem);
+    }
+    // Restore definition, code, prefix from metadata
+    if (fieldMeta?.definition)
+        item.definition = fieldMeta.definition;
+    if (fieldMeta?.code)
+        item.code = fieldMeta.code;
+    if (fieldMeta?.prefix)
+        item.prefix = fieldMeta.prefix;
+    return item;
+}
+function convertRulesToEnableWhen(rules) {
+    if (!rules)
+        return [];
+    // Only convert 'visible' rules to enableWhen
+    const visibleRule = rules.find((r) => r.effect === 'visible');
+    if (!visibleRule)
+        return [];
+    return visibleRule.conditions
+        .map((cond) => {
+        if (cond.conditionType === 'expression')
+            return null;
+        if (!cond.targetId || !cond.operator)
+            return null;
+        const fhirOp = mapEsheetOperatorToFhir(cond.operator);
+        if (!fhirOp)
+            return null;
+        const ew = {
+            question: cond.targetId,
+            operator: fhirOp.operator,
+        };
+        // Set the answer value
+        if (fhirOp.answerBoolean !== undefined) {
+            ew.answerBoolean = fhirOp.answerBoolean;
+        }
+        else if (cond.expected !== undefined) {
+            // Determine answer type based on expected value
+            if (cond.expected === 'true' || cond.expected === 'false') {
+                ew.answerBoolean =
+                    cond.expected === 'true';
+            }
+            else if (!isNaN(Number(cond.expected))) {
+                ew.answerDecimal = Number(cond.expected);
+            }
+            else {
+                ew.answerString = cond.expected;
+            }
+        }
+        return ew;
+    })
+        .filter((ew) => ew !== null);
+}
+// ---------------------------------------------------------------------------
+// Import: FHIR QuestionnaireResponse → Answers
+// ---------------------------------------------------------------------------
+/**
+ * Convert a FHIR QuestionnaireResponse to an eSheet answer map.
+ */
+export function importResponseFromFhir(response, options) {
+    const answers = {};
+    if (response.item) {
+        collectResponseAnswers(response.item, answers);
+    }
+    return answers;
+}
+function collectResponseAnswers(items, answers) {
+    for (const item of items) {
+        if (item.answer && item.answer.length > 0) {
+            answers[item.linkId] = extractAnswerValue(item.answer);
+        }
+        // Recurse into nested items
+        if (item.item) {
+            collectResponseAnswers(item.item, answers);
+        }
+        // Also recurse into answer-nested items
+        for (const ans of item.answer ?? []) {
+            if (ans.item) {
+                collectResponseAnswers(ans.item, answers);
+            }
+        }
+    }
+}
+function extractAnswerValue(answers) {
+    // Multiple answers → array (for repeating items)
+    if (answers.length > 1) {
+        return answers.map(extractSingleAnswerValue);
+    }
+    return extractSingleAnswerValue(answers[0]);
+}
+function extractSingleAnswerValue(answer) {
+    if (answer.valueBoolean !== undefined)
+        return answer.valueBoolean;
+    if (answer.valueDecimal !== undefined)
+        return answer.valueDecimal;
+    if (answer.valueInteger !== undefined)
+        return answer.valueInteger;
+    if (answer.valueDate !== undefined)
+        return answer.valueDate;
+    if (answer.valueDateTime !== undefined)
+        return answer.valueDateTime;
+    if (answer.valueTime !== undefined)
+        return answer.valueTime;
+    if (answer.valueString !== undefined)
+        return answer.valueString;
+    if (answer.valueUri !== undefined)
+        return answer.valueUri;
+    if (answer.valueCoding)
+        return answer.valueCoding.code;
+    if (answer.valueQuantity)
+        return answer.valueQuantity.value;
+    if (answer.valueAttachment)
+        return answer.valueAttachment.data;
+    if (answer.valueReference)
+        return answer.valueReference.reference;
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Export: Answers → FHIR QuestionnaireResponse
+// ---------------------------------------------------------------------------
+/**
+ * Convert eSheet answers to a FHIR QuestionnaireResponse.
+ */
+export function exportResponseToFhir(form, answers, options) {
+    const response = {
+        resourceType: 'QuestionnaireResponse',
+        ...(options.resourceId ? { id: options.resourceId } : {}),
+        questionnaire: options.questionnaireUrl,
+        status: options.status ?? 'completed',
+        ...(options.subject ? { subject: options.subject } : {}),
+        ...(options.author ? { author: options.author } : {}),
+        authored: new Date().toISOString(),
+        item: convertFieldsToResponseItems(form.fields, answers),
+    };
+    return response;
+}
+function convertFieldsToResponseItems(fields, answers) {
+    const items = [];
+    for (const field of fields) {
+        const item = convertFieldToResponseItem(field, answers);
+        if (item) {
+            items.push(item);
+        }
+    }
+    return items;
+}
+function convertFieldToResponseItem(field, answers) {
+    const value = answers[field.id];
+    // Handle sections recursively
+    if (field.fieldType === 'section' && 'fields' in field && field.fields) {
+        const nestedItems = convertFieldsToResponseItems(field.fields, answers);
+        if (nestedItems.length === 0)
+            return null;
+        return {
+            linkId: field.id,
+            text: field.question,
+            item: nestedItems,
+        };
+    }
+    // Skip fields with no answer
+    if (value === undefined || value === null || value === '') {
+        return null;
+    }
+    const item = {
+        linkId: field.id,
+        text: field.question,
+        answer: convertValueToAnswers(field, value),
+    };
+    return item;
+}
+function convertValueToAnswers(field, value) {
+    const inputType = 'inputType' in field ? field.inputType : undefined;
+    switch (field.fieldType) {
+        case 'text':
+        case 'longtext':
+            return [convertTextAnswer(value, inputType)];
+        case 'boolean':
+            return [{ valueBoolean: Boolean(value) }];
+        case 'radio':
+        case 'dropdown':
+            return [createCodingAnswer(field, value)];
+        case 'check':
+        case 'multiselectdropdown': {
+            const selected = Array.isArray(value) ? value : [value];
+            return selected.map((v) => createCodingAnswer(field, v));
+        }
+        case 'rating':
+        case 'slider':
+            return [{ valueInteger: Number(value) }];
+        case 'signature':
+        case 'diagram':
+            return [
+                {
+                    valueAttachment: {
+                        contentType: 'image/png',
+                        data: value,
+                    },
+                },
+            ];
+        default:
+            return [{ valueString: String(value) }];
+    }
+}
+function convertTextAnswer(value, inputType) {
+    switch (inputType) {
+        case 'number':
+            return { valueDecimal: Number(value) };
+        case 'date':
+            return { valueDate: value };
+        case 'datetime-local':
+            return { valueDateTime: value };
+        case 'time':
+            return { valueTime: value };
+        case 'url':
+            return { valueUri: value };
+        default:
+            return { valueString: String(value) };
+    }
+}
+function createCodingAnswer(field, selectedId) {
+    const options = 'options' in field ? field.options : undefined;
+    const option = options?.find((o) => o.id === selectedId);
+    return {
+        valueCoding: {
+            code: option?.value ?? selectedId,
+            display: option?.text,
+        },
+    };
+}

package/dist/fhir/index.d.ts

@@ -0,0 +1,5 @@
+export type { FhirCoding, FhirCodeableConcept, FhirReference, FhirIdentifier, FhirPeriod, FhirAttachment, FhirQuantity, FhirExpression, FhirExpressionLanguage, FhirExtension, FhirMeta, FhirContactDetail, FhirContactPoint, FhirUsageContext, FhirRange, FhirQuestionnaireStatus, FhirQuestionnaireItemType, FhirEnableWhenOperator, FhirEnableBehavior, FhirEnableWhen, FhirAnswerOption, FhirInitialValue, FhirQuestionnaireItem, FhirQuestionnaire, FhirResponseStatus, FhirResponseAnswer, FhirQuestionnaireResponseItem, FhirQuestionnaireResponse, FhirImportOptions, FhirExportOptions, ResponseImportOptions, ResponseExportOptions, ImportWarning, ImportWarningCode, ImportWarningSeverity, FhirFieldMeta, FhirFormMeta, } from './types.js';
+export { isFhirQuestionnaire, isFhirQuestionnaireResponse } from './utils.js';
+export { importFromFhir, exportToFhir, importResponseFromFhir, exportResponseToFhir, } from './fhir-adapter.js';
+export { mapFhirTypeToEsheet, mapEsheetTypeToFhir, convertAnswerOptionToFieldOption, convertOptionToFhirAnswerOption, mapFhirOperatorToEsheet, mapEsheetOperatorToFhir, getExtensionValue, createItemControlExtension, FHIR_EXT, ITEM_CONTROL_SYSTEM, } from './utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/fhir/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fhir/index.ts"],"names":[],"mappings":"AAKA,YAAY,EAEV,UAAU,EACV,mBAAmB,EACnB,aAAa,EACb,cAAc,EACd,UAAU,EACV,cAAc,EACd,YAAY,EACZ,cAAc,EACd,sBAAsB,EACtB,aAAa,EACb,QAAQ,EACR,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EAET,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,EACtB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EAEjB,kBAAkB,EAClB,kBAAkB,EAClB,6BAA6B,EAC7B,yBAAyB,EAEzB,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EAErB,aAAa,EACb,YAAY,GACb,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAG9E,OAAO,EACL,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,gCAAgC,EAChC,+BAA+B,EAC/B,uBAAuB,EACvB,uBAAuB,EACvB,iBAAiB,EACjB,0BAA0B,EAC1B,QAAQ,EACR,mBAAmB,GACpB,MAAM,YAAY,CAAC"}

package/dist/fhir/index.js

@@ -0,0 +1,9 @@
+// ---------------------------------------------------------------------------
+// FHIR Adapter - Public API
+// ---------------------------------------------------------------------------
+// Type guards
+export { isFhirQuestionnaire, isFhirQuestionnaireResponse } from './utils.js';
+// Adapter functions
+export { importFromFhir, exportToFhir, importResponseFromFhir, exportResponseToFhir, } from './fhir-adapter.js';
+// Utility functions (for advanced users)
+export { mapFhirTypeToEsheet, mapEsheetTypeToFhir, convertAnswerOptionToFieldOption, convertOptionToFhirAnswerOption, mapFhirOperatorToEsheet, mapEsheetOperatorToFhir, getExtensionValue, createItemControlExtension, FHIR_EXT, ITEM_CONTROL_SYSTEM, } from './utils.js';