fhir-data-utils-ts 0.2.4 → 0.3.1

package/dist/research-study-r5.js

@@ -0,0 +1,490 @@
+/**
+ * Browser-safe FHIR R5 ResearchStudy flat-claim contract.
+ *
+ * The standard catalogue is copied from the R5 SearchParameter definitions,
+ * not inferred from similarly named resource elements. In particular, the
+ * `date` SearchParameter targets `ResearchStudy.period`, not the publication
+ * date element. Associated-party projections are indexed separately because
+ * base R5 defines no ResearchStudy party SearchParameter.
+ *
+ * @see https://hl7.org/fhir/R5/researchstudy.html
+ * @see https://hl7.org/fhir/R5/researchstudy-search.html
+ */
+export const ResearchStudyR5Version = '5.0.0';
+/**
+ * Immutable codes defined by the FHIR R5 5.0.0 ResearchStudy party-role code
+ * system. The element binding remains extensible; this catalogue is the closed
+ * set a portal may offer by default, not a validator for every conformant
+ * external Coding.
+ *
+ * @see https://hl7.org/fhir/R5/codesystem-research-study-party-role.html
+ */
+export const ResearchStudyR5PartyRoleSystem = 'http://hl7.org/fhir/research-study-party-role';
+export const ResearchStudyR5PartyRoleCodes = Object.freeze([
+    'sponsor',
+    'lead-sponsor',
+    'sponsor-investigator',
+    'primary-investigator',
+    'collaborator',
+    'funding-source',
+    'general-contact',
+    'recruitment-contact',
+    'sub-investigator',
+    'study-director',
+    'study-chair',
+    'irb',
+]);
+export const ResearchStudyAssociatedPartyBindings = Object.freeze({
+    role: Object.freeze({
+        valueSet: 'http://hl7.org/fhir/ValueSet/research-study-party-role',
+        strength: 'extensible',
+    }),
+    classifier: Object.freeze({
+        valueSet: 'http://hl7.org/fhir/ValueSet/research-study-party-organization-type',
+        strength: 'example',
+    }),
+});
+const searchParameter = (code, type, expression, components = []) => Object.freeze({
+    code,
+    type,
+    expression,
+    components: Object.freeze([...components]),
+});
+/** Exact resource-specific SearchParameters published by FHIR R5 5.0.0. */
+export const ResearchStudyR5SearchParameterCatalog = Object.freeze([
+    searchParameter('classifier', 'token', 'ResearchStudy.classifier'),
+    searchParameter('condition', 'token', 'ResearchStudy.condition'),
+    searchParameter('date', 'date', 'ResearchStudy.period'),
+    searchParameter('description', 'string', 'ResearchStudy.description'),
+    searchParameter('eligibility', 'reference', 'ResearchStudy.recruitment.eligibility'),
+    searchParameter('focus-code', 'token', 'ResearchStudy.focus.concept'),
+    searchParameter('focus-reference', 'reference', 'ResearchStudy.focus.reference'),
+    searchParameter('identifier', 'token', 'ResearchStudy.identifier'),
+    searchParameter('keyword', 'token', 'ResearchStudy.keyword'),
+    searchParameter('name', 'string', 'ResearchStudy.name'),
+    searchParameter('objective-description', 'string', 'ResearchStudy.objective.description'),
+    searchParameter('objective-type', 'token', 'ResearchStudy.objective.type'),
+    searchParameter('part-of', 'reference', 'ResearchStudy.partOf'),
+    searchParameter('phase', 'token', 'ResearchStudy.phase'),
+    searchParameter('progress-status-state-actual', 'composite', 'ResearchStudy.progressStatus', [
+        'http://hl7.org/fhir/SearchParameter/ResearchStudy-state',
+        'http://hl7.org/fhir/SearchParameter/ResearchStudy-actual',
+    ]),
+    searchParameter('progress-status-state-period', 'composite', 'ResearchStudy.progressStatus', [
+        'http://hl7.org/fhir/SearchParameter/ResearchStudy-state',
+        'http://hl7.org/fhir/SearchParameter/ResearchStudy-period',
+    ]),
+    searchParameter('progress-status-state-period-actual', 'composite', 'ResearchStudy.progressStatus', [
+        'http://hl7.org/fhir/SearchParameter/ResearchStudy-state',
+        'http://hl7.org/fhir/SearchParameter/ResearchStudy-period',
+        'http://hl7.org/fhir/SearchParameter/ResearchStudy-actual',
+    ]),
+    searchParameter('protocol', 'reference', 'ResearchStudy.protocol'),
+    searchParameter('recruitment-actual', 'number', 'ResearchStudy.recruitment.actualNumber'),
+    searchParameter('recruitment-target', 'number', 'ResearchStudy.recruitment.targetNumber'),
+    searchParameter('region', 'token', 'ResearchStudy.region'),
+    searchParameter('site', 'reference', 'ResearchStudy.site'),
+    searchParameter('status', 'token', 'ResearchStudy.status'),
+    searchParameter('study-design', 'token', 'ResearchStudy.studyDesign'),
+    searchParameter('title', 'string', 'ResearchStudy.title'),
+]);
+/** Canonical ResearchStudy flat-claim names. Never repeat these storage keys as literals. */
+export const ResearchStudyClaim = Object.freeze({
+    Classifier: 'ResearchStudy.classifier',
+    Condition: 'ResearchStudy.condition',
+    Date: 'ResearchStudy.date',
+    Description: 'ResearchStudy.description',
+    Eligibility: 'ResearchStudy.eligibility',
+    FocusCode: 'ResearchStudy.focus-code',
+    FocusReference: 'ResearchStudy.focus-reference',
+    Identifier: 'ResearchStudy.identifier',
+    Keyword: 'ResearchStudy.keyword',
+    Name: 'ResearchStudy.name',
+    ObjectiveDescription: 'ResearchStudy.objective-description',
+    ObjectiveType: 'ResearchStudy.objective-type',
+    PartOf: 'ResearchStudy.part-of',
+    Phase: 'ResearchStudy.phase',
+    ProgressStatusStateActual: 'ResearchStudy.progress-status-state-actual',
+    ProgressStatusStatePeriod: 'ResearchStudy.progress-status-state-period',
+    ProgressStatusStatePeriodActual: 'ResearchStudy.progress-status-state-period-actual',
+    Protocol: 'ResearchStudy.protocol',
+    RecruitmentActual: 'ResearchStudy.recruitment-actual',
+    RecruitmentTarget: 'ResearchStudy.recruitment-target',
+    Region: 'ResearchStudy.region',
+    Site: 'ResearchStudy.site',
+    Status: 'ResearchStudy.status',
+    StudyDesign: 'ResearchStudy.study-design',
+    Title: 'ResearchStudy.title',
+    PartyName: 'ResearchStudy.party-name',
+    PartyRole: 'ResearchStudy.party-role',
+    PartyPeriodStart: 'ResearchStudy.party-period-start',
+    PartyPeriodEnd: 'ResearchStudy.party-period-end',
+    PartyClassifier: 'ResearchStudy.party-classifier',
+    Party: 'ResearchStudy.party',
+});
+const standardSearchClaims = Object.freeze([
+    ResearchStudyClaim.Classifier, ResearchStudyClaim.Condition, ResearchStudyClaim.Date,
+    ResearchStudyClaim.Description, ResearchStudyClaim.Eligibility, ResearchStudyClaim.FocusCode,
+    ResearchStudyClaim.FocusReference, ResearchStudyClaim.Identifier, ResearchStudyClaim.Keyword,
+    ResearchStudyClaim.Name, ResearchStudyClaim.ObjectiveDescription, ResearchStudyClaim.ObjectiveType,
+    ResearchStudyClaim.PartOf, ResearchStudyClaim.Phase, ResearchStudyClaim.ProgressStatusStateActual,
+    ResearchStudyClaim.ProgressStatusStatePeriod, ResearchStudyClaim.ProgressStatusStatePeriodActual,
+    ResearchStudyClaim.Protocol, ResearchStudyClaim.RecruitmentActual, ResearchStudyClaim.RecruitmentTarget,
+    ResearchStudyClaim.Region, ResearchStudyClaim.Site, ResearchStudyClaim.Status,
+    ResearchStudyClaim.StudyDesign, ResearchStudyClaim.Title,
+]);
+const associatedPartyClaims = Object.freeze([
+    ResearchStudyClaim.PartyName, ResearchStudyClaim.PartyRole, ResearchStudyClaim.PartyPeriodStart,
+    ResearchStudyClaim.PartyPeriodEnd, ResearchStudyClaim.PartyClassifier, ResearchStudyClaim.Party,
+]);
+/**
+ * Governed flat claims for ResearchStudy.
+ *
+ * `standardSearch` contains only official R5 SearchParameters. The
+ * `associatedParty` list is an explicit operational projection of the R5
+ * backbone element; none of those names is advertised as a standard search
+ * parameter and `classifier` never carries CRUD or authorization policy.
+ */
+export const ResearchStudyFlatClaimCatalog = Object.freeze({
+    standardSearch: standardSearchClaims,
+    associatedParty: associatedPartyClaims,
+    all: Object.freeze([...standardSearchClaims, ...associatedPartyClaims]),
+});
+/**
+ * Projects the official resource-specific R5 SearchParameters from one native
+ * ResearchStudy into flat `resource.meta.claims`. Composite values use FHIR's
+ * `$` component separator; associatedParty remains a separate projection and
+ * never becomes authorization data.
+ *
+ * @see https://hl7.org/fhir/R5/researchstudy-search.html
+ */
+export function projectResearchStudyR5SearchClaims(input) {
+    if (!isRecord(input) || input.resourceType !== 'ResearchStudy') {
+        throw new TypeError('research_study_resource_invalid');
+    }
+    const claims = {};
+    addClaim(claims, ResearchStudyClaim.Classifier, conceptsValue(input.classifier, 'research_study_classifier_invalid'));
+    addClaim(claims, ResearchStudyClaim.Condition, conceptsValue(input.condition, 'research_study_condition_invalid'));
+    addClaim(claims, ResearchStudyClaim.Date, periodValues(input.period, 'research_study_period_invalid'));
+    addClaim(claims, ResearchStudyClaim.Description, strings(input.description));
+    addClaim(claims, ResearchStudyClaim.Eligibility, references(input.recruitment, 'eligibility'));
+    addClaim(claims, ResearchStudyClaim.FocusCode, codeableReferences(input.focus, 'concept'));
+    addClaim(claims, ResearchStudyClaim.FocusReference, codeableReferences(input.focus, 'reference'));
+    addClaim(claims, ResearchStudyClaim.Identifier, identifiers(input.identifier));
+    addClaim(claims, ResearchStudyClaim.Keyword, conceptsValue(input.keyword, 'research_study_keyword_invalid'));
+    addClaim(claims, ResearchStudyClaim.Name, strings(input.name));
+    addClaim(claims, ResearchStudyClaim.ObjectiveDescription, backboneStrings(input.objective, 'description'));
+    addClaim(claims, ResearchStudyClaim.ObjectiveType, backboneConcepts(input.objective, 'type'));
+    addClaim(claims, ResearchStudyClaim.PartOf, references(input.partOf));
+    addClaim(claims, ResearchStudyClaim.Phase, conceptsValue(input.phase, 'research_study_phase_invalid'));
+    const progress = progressStatusValues(input.progressStatus);
+    addClaim(claims, ResearchStudyClaim.ProgressStatusStateActual, progress.stateActual);
+    addClaim(claims, ResearchStudyClaim.ProgressStatusStatePeriod, progress.statePeriod);
+    addClaim(claims, ResearchStudyClaim.ProgressStatusStatePeriodActual, progress.statePeriodActual);
+    addClaim(claims, ResearchStudyClaim.Protocol, references(input.protocol));
+    addClaim(claims, ResearchStudyClaim.RecruitmentActual, nestedNumber(input.recruitment, 'actualNumber'));
+    addClaim(claims, ResearchStudyClaim.RecruitmentTarget, nestedNumber(input.recruitment, 'targetNumber'));
+    addClaim(claims, ResearchStudyClaim.Region, conceptsValue(input.region, 'research_study_region_invalid'));
+    addClaim(claims, ResearchStudyClaim.Site, references(input.site));
+    addClaim(claims, ResearchStudyClaim.Status, strings(input.status));
+    addClaim(claims, ResearchStudyClaim.StudyDesign, conceptsValue(input.studyDesign, 'research_study_design_invalid'));
+    addClaim(claims, ResearchStudyClaim.Title, strings(input.title));
+    return Object.freeze(claims);
+}
+/**
+ * Normalizes the R5 `associatedParty[]` backbone without flattening parties
+ * into unrelated parallel arrays. This function validates data shape only; it
+ * does not grant study access or interpret classifier values as permissions.
+ */
+export function normalizeResearchStudyAssociatedParties(input) {
+    if (!Array.isArray(input))
+        throw new TypeError('research_study_associated_parties_invalid');
+    return Object.freeze(input.map((value, index) => normalizeAssociatedParty(value, index)));
+}
+/**
+ * Produces one flat-claim map per associated party. Keeping the normalized
+ * party beside each map preserves the party/role/period/classifier boundary
+ * required when a later Bundle PATCH changes one party.
+ */
+export function projectResearchStudyAssociatedPartyClaims(input) {
+    const parties = normalizeResearchStudyAssociatedParties(input);
+    return Object.freeze(parties.map(party => Object.freeze({
+        associatedParty: party,
+        claims: Object.freeze({
+            [ResearchStudyClaim.PartyName]: Object.freeze(party.name ? [party.name] : []),
+            [ResearchStudyClaim.PartyRole]: Object.freeze(conceptValues([party.role])),
+            [ResearchStudyClaim.PartyPeriodStart]: Object.freeze((party.period || []).flatMap(period => period.start ? [period.start] : [])),
+            [ResearchStudyClaim.PartyPeriodEnd]: Object.freeze((party.period || []).flatMap(period => period.end ? [period.end] : [])),
+            [ResearchStudyClaim.PartyClassifier]: Object.freeze(conceptValues(party.classifier || [])),
+            [ResearchStudyClaim.Party]: Object.freeze(party.party ? [party.party.reference] : []),
+        }),
+    })));
+}
+/** Projects native-shaped study input to the claims-only GW persistence shape. */
+export function projectResearchStudyR5FlatClaimsResource(input) {
+    if (!isRecord(input) || input.resourceType !== 'ResearchStudy')
+        throw new TypeError('research_study_resource_invalid');
+    const id = fhirId(input.id, 'research_study_flat_resource_invalid');
+    if (input.associatedParty !== undefined)
+        throw new TypeError('research_study_parties_require_separate_resources');
+    return normalizeResearchStudyR5FlatClaimsResource({
+        resourceType: 'ResearchStudy',
+        id,
+        meta: { claims: projectResearchStudyR5SearchClaims(input) },
+    });
+}
+/** Projects one correlated claims-only GW resource per associated party. */
+export function projectResearchStudyAssociatedPartyFlatClaimResources(input) {
+    const id = fhirId(input.researchStudyId, 'research_study_flat_resource_invalid');
+    return Object.freeze(projectResearchStudyAssociatedPartyClaims(input.associatedParties).map(projection => {
+        const claims = Object.fromEntries(Object.entries(projection.claims).filter(([, values]) => values.length > 0));
+        return normalizeResearchStudyR5FlatClaimsResource({ resourceType: 'ResearchStudy', id, meta: { claims } });
+    }));
+}
+/** Validates and freezes a claims-only ResearchStudy GW resource. */
+export function normalizeResearchStudyR5FlatClaimsResource(input) {
+    if (!isRecord(input)
+        || input.resourceType !== 'ResearchStudy'
+        || Object.keys(input).some(key => !['resourceType', 'id', 'meta'].includes(key))) {
+        throw new TypeError('research_study_flat_resource_invalid');
+    }
+    const id = fhirId(input.id, 'research_study_flat_resource_invalid');
+    if (!isRecord(input.meta) || !isRecord(input.meta.claims))
+        throw new TypeError('research_study_flat_resource_invalid');
+    const claims = {};
+    for (const [name, rawValues] of Object.entries(input.meta.claims)) {
+        if (!ResearchStudyFlatClaimCatalog.all.includes(name)
+            || !Array.isArray(rawValues)
+            || rawValues.length === 0
+            || rawValues.some(value => typeof value !== 'string' || !value.trim())) {
+            throw new TypeError('research_study_flat_claim_invalid');
+        }
+        claims[name] = Object.freeze(rawValues.map(value => value.trim()));
+    }
+    return Object.freeze({ resourceType: 'ResearchStudy', id, meta: Object.freeze({ claims: Object.freeze(claims) }) });
+}
+function normalizeAssociatedParty(value, index) {
+    if (!isRecord(value))
+        throw new TypeError(`research_study_associated_party_${index}_invalid`);
+    const role = normalizeConcept(value.role, `research_study_associated_party_${index}_role_required`);
+    const name = optionalString(value.name);
+    const period = value.period === undefined
+        ? undefined
+        : normalizePeriods(value.period, index);
+    const classifier = value.classifier === undefined
+        ? undefined
+        : normalizeConcepts(value.classifier, `research_study_associated_party_${index}_classifier_invalid`);
+    const party = value.party === undefined ? undefined : normalizePartyReference(value.party, index);
+    return Object.freeze({
+        ...(name ? { name } : {}),
+        role,
+        ...(period ? { period } : {}),
+        ...(classifier ? { classifier } : {}),
+        ...(party ? { party } : {}),
+    });
+}
+function normalizeConcepts(value, error) {
+    if (!Array.isArray(value))
+        throw new TypeError(error);
+    return Object.freeze(value.map(item => normalizeConcept(item, error)));
+}
+function normalizeConcept(value, error) {
+    if (!isRecord(value))
+        throw new TypeError(error);
+    const text = optionalString(value.text);
+    let coding;
+    if (value.coding !== undefined) {
+        if (!Array.isArray(value.coding))
+            throw new TypeError(error);
+        coding = Object.freeze(value.coding.map(item => normalizeCoding(item, error)));
+    }
+    if (!text && (!coding || coding.length === 0 || !coding.some(item => item.code)))
+        throw new TypeError(error);
+    return Object.freeze({ ...(coding ? { coding } : {}), ...(text ? { text } : {}) });
+}
+function normalizeCoding(value, error) {
+    if (!isRecord(value))
+        throw new TypeError(error);
+    const system = optionalString(value.system);
+    const code = optionalString(value.code);
+    const display = optionalString(value.display);
+    if (!code && !display)
+        throw new TypeError(error);
+    return Object.freeze({ ...(system ? { system } : {}), ...(code ? { code } : {}), ...(display ? { display } : {}) });
+}
+function normalizePeriods(value, index) {
+    if (!Array.isArray(value))
+        throw new TypeError(`research_study_associated_party_${index}_period_invalid`);
+    return Object.freeze(value.map(item => {
+        if (!isRecord(item))
+            throw new TypeError(`research_study_associated_party_${index}_period_invalid`);
+        const start = optionalString(item.start);
+        const end = optionalString(item.end);
+        if (!start && !end)
+            throw new TypeError(`research_study_associated_party_${index}_period_invalid`);
+        if ((start && !isFhirDateTime(start)) || (end && !isFhirDateTime(end))) {
+            throw new TypeError(`research_study_associated_party_${index}_period_invalid`);
+        }
+        if (start && end && Date.parse(end) < Date.parse(start)) {
+            throw new TypeError(`research_study_associated_party_${index}_period_invalid`);
+        }
+        return Object.freeze({ ...(start ? { start } : {}), ...(end ? { end } : {}) });
+    }));
+}
+function normalizePartyReference(value, index) {
+    const error = `research_study_associated_party_${index}_party_reference_invalid`;
+    if (!isRecord(value))
+        throw new TypeError(error);
+    const reference = optionalString(value.reference);
+    const type = optionalString(value.type);
+    const display = optionalString(value.display);
+    if (!reference)
+        throw new TypeError(error);
+    const allowed = ['Organization', 'Practitioner', 'PractitionerRole'];
+    if (type && !allowed.includes(type))
+        throw new TypeError(error);
+    const relativeType = reference.match(/^(Organization|Practitioner|PractitionerRole|[A-Z][A-Za-z]+)\//)?.[1];
+    if (relativeType && !allowed.includes(relativeType))
+        throw new TypeError(error);
+    return Object.freeze({
+        reference,
+        ...(type ? { type: type } : {}),
+        ...(display ? { display } : {}),
+    });
+}
+function conceptValues(concepts) {
+    return concepts.flatMap(concept => {
+        const coded = (concept.coding || []).flatMap(coding => coding.code
+            ? [`${coding.system ? `${coding.system}|` : ''}${coding.code}`]
+            : []);
+        return coded.length > 0 ? coded : concept.text ? [concept.text] : [];
+    });
+}
+function addClaim(claims, name, values) {
+    if (values.length > 0)
+        claims[name] = Object.freeze([...values]);
+}
+function strings(value) {
+    const result = optionalString(value);
+    return result ? [result] : [];
+}
+function conceptsValue(value, error) {
+    if (value === undefined)
+        return [];
+    const concepts = Array.isArray(value)
+        ? normalizeConcepts(value, error)
+        : Object.freeze([normalizeConcept(value, error)]);
+    return conceptValues(concepts);
+}
+function references(value, nestedKey) {
+    let candidate = value;
+    if (nestedKey) {
+        if (!isRecord(value))
+            return [];
+        candidate = value[nestedKey];
+    }
+    if (candidate === undefined)
+        return [];
+    const items = Array.isArray(candidate) ? candidate : [candidate];
+    return items.flatMap(item => isRecord(item) && optionalString(item.reference) ? [String(item.reference).trim()] : []);
+}
+function identifiers(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new TypeError('research_study_identifier_invalid');
+    return value.flatMap(item => {
+        if (!isRecord(item))
+            throw new TypeError('research_study_identifier_invalid');
+        const system = optionalString(item.system);
+        const identifier = optionalString(item.value);
+        return identifier ? [`${system ? `${system}|` : ''}${identifier}`] : [];
+    });
+}
+function periodValues(value, error) {
+    if (value === undefined)
+        return [];
+    if (!isRecord(value))
+        throw new TypeError(error);
+    const start = optionalString(value.start);
+    const end = optionalString(value.end);
+    if ((start && !isFhirDateTime(start)) || (end && !isFhirDateTime(end)))
+        throw new TypeError(error);
+    return [start, end].filter((item) => Boolean(item));
+}
+function codeableReferences(value, key) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new TypeError('research_study_focus_invalid');
+    return value.flatMap(item => {
+        if (!isRecord(item))
+            throw new TypeError('research_study_focus_invalid');
+        return key === 'concept'
+            ? conceptsValue(item.concept, 'research_study_focus_invalid')
+            : references(item.reference);
+    });
+}
+function backboneStrings(value, key) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new TypeError('research_study_backbone_invalid');
+    return value.flatMap(item => isRecord(item) ? strings(item[key]) : []);
+}
+function backboneConcepts(value, key) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new TypeError('research_study_backbone_invalid');
+    return value.flatMap(item => isRecord(item) ? conceptsValue(item[key], 'research_study_backbone_invalid') : []);
+}
+function nestedNumber(value, key) {
+    if (!isRecord(value) || value[key] === undefined)
+        return [];
+    const number = Number(value[key]);
+    if (!Number.isInteger(number) || number < 0)
+        throw new TypeError('research_study_recruitment_invalid');
+    return [String(number)];
+}
+function progressStatusValues(value) {
+    const result = { stateActual: [], statePeriod: [], statePeriodActual: [] };
+    if (value === undefined)
+        return result;
+    if (!Array.isArray(value))
+        throw new TypeError('research_study_progress_status_invalid');
+    for (const item of value) {
+        if (!isRecord(item))
+            throw new TypeError('research_study_progress_status_invalid');
+        const states = conceptsValue(item.state, 'research_study_progress_status_invalid');
+        const dates = periodValues(item.period, 'research_study_progress_status_invalid');
+        const actual = typeof item.actual === 'boolean' ? String(item.actual) : undefined;
+        for (const state of states) {
+            if (actual)
+                result.stateActual.push(`${state}$${actual}`);
+            for (const date of dates) {
+                result.statePeriod.push(`${state}$${date}`);
+                if (actual)
+                    result.statePeriodActual.push(`${state}$${date}$${actual}`);
+            }
+        }
+    }
+    return result;
+}
+function optionalString(value) {
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    return normalized || undefined;
+}
+function isFhirDateTime(value) {
+    return /^\d{4}(?:-\d{2}(?:-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}))?)?)?$/.test(value)
+        && !Number.isNaN(Date.parse(value));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function fhirId(value, error) {
+    const id = optionalString(value);
+    if (!id || !/^[A-Za-z0-9.-]{1,64}$/.test(id))
+        throw new TypeError(error);
+    return id;
+}

package/dist/search-models/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resource-specific search models recovered from the original UHC package.
+ * Runtime parsing and serialization use `fhir-search-parameters`; these are
+ * compile-time compatibility surfaces, not a second query implementation.
+ */
+export * from './params/index.js';
+export * from './templates/index.js';

package/dist/search-models/index.js

@@ -0,0 +1,7 @@
+/**
+ * Resource-specific search models recovered from the original UHC package.
+ * Runtime parsing and serialization use `fhir-search-parameters`; these are
+ * compile-time compatibility surfaces, not a second query implementation.
+ */
+export * from './params/index.js';
+export * from './templates/index.js';

package/dist/search-models/params/AdverseEvent.params.model.d.ts

@@ -0,0 +1,14 @@
+export declare enum AdverseEventParameters {
+    Category = "org.hl7.fhir.api.AdverseEvent.category",
+    Date = "org.hl7.fhir.api.AdverseEvent.date",
+    Identifier = "org.hl7.fhir.api.AdverseEvent.identifier",
+    Location = "org.hl7.fhir.api.AdverseEvent.location",
+    Reaction = "org.hl7.fhir.api.AdverseEvent.reaction",
+    Recorder = "org.hl7.fhir.api.AdverseEvent.recorder",
+    Seriousness = "org.hl7.fhir.api.AdverseEvent.seriousness",
+    Study = "org.hl7.fhir.api.AdverseEvent.study",
+    Subject = "org.hl7.fhir.api.AdverseEvent.subject",
+    Substance = "org.hl7.fhir.api.AdverseEvent.substance",
+    RecordedDate = "org.hl7.fhir.api.AdverseEvent.recorder-date",
+    ReferenceDocument = "org.hl7.fhir.api.AdverseEvent.reference-document"
+}

package/dist/search-models/params/AdverseEvent.params.model.js

@@ -0,0 +1,16 @@
+// Create the TypeScript enumerator for the HTTP parameters of the AdverseEvent resource
+export var AdverseEventParameters;
+(function (AdverseEventParameters) {
+    AdverseEventParameters["Category"] = "org.hl7.fhir.api.AdverseEvent.category";
+    AdverseEventParameters["Date"] = "org.hl7.fhir.api.AdverseEvent.date";
+    AdverseEventParameters["Identifier"] = "org.hl7.fhir.api.AdverseEvent.identifier";
+    AdverseEventParameters["Location"] = "org.hl7.fhir.api.AdverseEvent.location";
+    AdverseEventParameters["Reaction"] = "org.hl7.fhir.api.AdverseEvent.reaction";
+    AdverseEventParameters["Recorder"] = "org.hl7.fhir.api.AdverseEvent.recorder";
+    AdverseEventParameters["Seriousness"] = "org.hl7.fhir.api.AdverseEvent.seriousness";
+    AdverseEventParameters["Study"] = "org.hl7.fhir.api.AdverseEvent.study";
+    AdverseEventParameters["Subject"] = "org.hl7.fhir.api.AdverseEvent.subject";
+    AdverseEventParameters["Substance"] = "org.hl7.fhir.api.AdverseEvent.substance";
+    AdverseEventParameters["RecordedDate"] = "org.hl7.fhir.api.AdverseEvent.recorder-date";
+    AdverseEventParameters["ReferenceDocument"] = "org.hl7.fhir.api.AdverseEvent.reference-document";
+})(AdverseEventParameters || (AdverseEventParameters = {}));

package/dist/search-models/params/AllergyIntolerance.params.model.d.ts

@@ -0,0 +1,24 @@
+export declare enum AllergyIntoleranceParameters {
+    Category = "org.hl7.fhir.api.AllergyIntolerance.category",
+    ClinicalStatus = "org.hl7.fhir.api.AllergyIntolerance.clinical-status",
+    Code = "org.hl7.fhir.api.AllergyIntolerance.code",
+    Criticality = "org.hl7.fhir.api.AllergyIntolerance.criticality",
+    Date = "org.hl7.fhir.api.AllergyIntolerance.date",
+    Identifier = "org.hl7.fhir.api.AllergyIntolerance.identifier",
+    LastDate = "org.hl7.fhir.api.AllergyIntolerance.last-date",
+    Patient = "org.hl7.fhir.api.AllergyIntolerance.patient",
+    Recorder = "org.hl7.fhir.api.AllergyIntolerance.recorder",
+    Reporter = "org.hl7.fhir.api.AllergyIntolerance.reporter",
+    Type = "org.hl7.fhir.api.AllergyIntolerance.type",
+    VerificationStatus = "org.hl7.fhir.api.AllergyIntolerance.verification-status",
+    Asserter = "org.hl7.fhir.api.AllergyIntolerance.Asserter",
+    Id = "org.hl7.fhir.api.AllergyIntolerance.Id",
+    Note = "org.hl7.fhir.api.AllergyIntolerance.note",
+    Severity = "org.hl7.fhir.api.AllergyIntolerance.severity",
+    Onset = "org.hl7.fhir.api.AllergyIntolerance.onset",
+    Manifestation = "org.hl7.fhir.api.AllergyIntolerance.manifestation",
+    ExposureRoute = "org.hl7.fhir.api.AllergyIntolerance.exposure-route",
+    Substance = "org.hl7.fhir.api.AllergyIntolerance.substance",
+    ReactionNote = "org.hl7.fhir.api.AllergyIntolerance.reaction-note",
+    ReactionDescription = "org.hl7.fhir.api.AllergyIntolerance.reaction-description"
+}

package/dist/search-models/params/AllergyIntolerance.params.model.js

@@ -0,0 +1,27 @@
+// Added extra parameter "note"
+// Create the TypeScript enumerator for the HTTP parameters of the AllergyIntolerance resource
+export var AllergyIntoleranceParameters;
+(function (AllergyIntoleranceParameters) {
+    AllergyIntoleranceParameters["Category"] = "org.hl7.fhir.api.AllergyIntolerance.category";
+    AllergyIntoleranceParameters["ClinicalStatus"] = "org.hl7.fhir.api.AllergyIntolerance.clinical-status";
+    AllergyIntoleranceParameters["Code"] = "org.hl7.fhir.api.AllergyIntolerance.code";
+    AllergyIntoleranceParameters["Criticality"] = "org.hl7.fhir.api.AllergyIntolerance.criticality";
+    AllergyIntoleranceParameters["Date"] = "org.hl7.fhir.api.AllergyIntolerance.date";
+    AllergyIntoleranceParameters["Identifier"] = "org.hl7.fhir.api.AllergyIntolerance.identifier";
+    AllergyIntoleranceParameters["LastDate"] = "org.hl7.fhir.api.AllergyIntolerance.last-date";
+    AllergyIntoleranceParameters["Patient"] = "org.hl7.fhir.api.AllergyIntolerance.patient";
+    AllergyIntoleranceParameters["Recorder"] = "org.hl7.fhir.api.AllergyIntolerance.recorder";
+    AllergyIntoleranceParameters["Reporter"] = "org.hl7.fhir.api.AllergyIntolerance.reporter";
+    AllergyIntoleranceParameters["Type"] = "org.hl7.fhir.api.AllergyIntolerance.type";
+    AllergyIntoleranceParameters["VerificationStatus"] = "org.hl7.fhir.api.AllergyIntolerance.verification-status";
+    AllergyIntoleranceParameters["Asserter"] = "org.hl7.fhir.api.AllergyIntolerance.Asserter";
+    AllergyIntoleranceParameters["Id"] = "org.hl7.fhir.api.AllergyIntolerance.Id";
+    AllergyIntoleranceParameters["Note"] = "org.hl7.fhir.api.AllergyIntolerance.note";
+    AllergyIntoleranceParameters["Severity"] = "org.hl7.fhir.api.AllergyIntolerance.severity";
+    AllergyIntoleranceParameters["Onset"] = "org.hl7.fhir.api.AllergyIntolerance.onset";
+    AllergyIntoleranceParameters["Manifestation"] = "org.hl7.fhir.api.AllergyIntolerance.manifestation";
+    AllergyIntoleranceParameters["ExposureRoute"] = "org.hl7.fhir.api.AllergyIntolerance.exposure-route";
+    AllergyIntoleranceParameters["Substance"] = "org.hl7.fhir.api.AllergyIntolerance.substance";
+    AllergyIntoleranceParameters["ReactionNote"] = "org.hl7.fhir.api.AllergyIntolerance.reaction-note";
+    AllergyIntoleranceParameters["ReactionDescription"] = "org.hl7.fhir.api.AllergyIntolerance.reaction-description";
+})(AllergyIntoleranceParameters || (AllergyIntoleranceParameters = {}));

package/dist/search-models/params/Appointment.params.model.d.ts

@@ -0,0 +1,12 @@
+export declare enum AppointmentParameters {
+    Actor = "org.hl7.fhir.api.Appointment.actor",
+    Date = "org.hl7.fhir.api.Appointment.date",
+    Identifier = "org.hl7.fhir.api.Appointment.identifier",
+    Location = "org.hl7.fhir.api.Appointment.location",
+    PartStatus = "org.hl7.fhir.api.Appointment.part-status",
+    Patient = "org.hl7.fhir.api.Appointment.patient",
+    Practitioner = "org.hl7.fhir.api.Appointment.practitioner",
+    ServiceType = "org.hl7.fhir.api.Appointment.service-type",
+    Status = "org.hl7.fhir.api.Appointment.status",
+    Specialty = "org.hl7.fhir.api.Appointment.specialty"
+}

package/dist/search-models/params/Appointment.params.model.js

@@ -0,0 +1,14 @@
+// Create the TypeScript enumerator for the HTTP parameters of the Appointment resource
+export var AppointmentParameters;
+(function (AppointmentParameters) {
+    AppointmentParameters["Actor"] = "org.hl7.fhir.api.Appointment.actor";
+    AppointmentParameters["Date"] = "org.hl7.fhir.api.Appointment.date";
+    AppointmentParameters["Identifier"] = "org.hl7.fhir.api.Appointment.identifier";
+    AppointmentParameters["Location"] = "org.hl7.fhir.api.Appointment.location";
+    AppointmentParameters["PartStatus"] = "org.hl7.fhir.api.Appointment.part-status";
+    AppointmentParameters["Patient"] = "org.hl7.fhir.api.Appointment.patient";
+    AppointmentParameters["Practitioner"] = "org.hl7.fhir.api.Appointment.practitioner";
+    AppointmentParameters["ServiceType"] = "org.hl7.fhir.api.Appointment.service-type";
+    AppointmentParameters["Status"] = "org.hl7.fhir.api.Appointment.status";
+    AppointmentParameters["Specialty"] = "org.hl7.fhir.api.Appointment.specialty";
+})(AppointmentParameters || (AppointmentParameters = {}));

package/dist/search-models/params/ClinicalImpression.params.model.d.ts

@@ -0,0 +1,14 @@
+export declare enum ClinicalImpressionParameters {
+    Assessor = "org.hl7.fhir.api.ClinicalImpression.assessor",
+    Date = "org.hl7.fhir.api.ClinicalImpression.date",
+    FindingCode = "org.hl7.fhir.api.ClinicalImpression.finding-code",
+    FindingRef = "org.hl7.fhir.api.ClinicalImpression.finding-ref",
+    Identifier = "org.hl7.fhir.api.ClinicalImpression.identifier",
+    Investigation = "org.hl7.fhir.api.ClinicalImpression.investigation",
+    Patient = "org.hl7.fhir.api.ClinicalImpression.patient",
+    Previous = "org.hl7.fhir.api.ClinicalImpression.previous",
+    Problem = "org.hl7.fhir.api.ClinicalImpression.problem",
+    Status = "org.hl7.fhir.api.ClinicalImpression.status",
+    Support = "org.hl7.fhir.api.ClinicalImpression.support",
+    Subject = "org.hl7.fhir.api.ClinicalImpression.subject"
+}

package/dist/search-models/params/ClinicalImpression.params.model.js

@@ -0,0 +1,15 @@
+export var ClinicalImpressionParameters;
+(function (ClinicalImpressionParameters) {
+    ClinicalImpressionParameters["Assessor"] = "org.hl7.fhir.api.ClinicalImpression.assessor";
+    ClinicalImpressionParameters["Date"] = "org.hl7.fhir.api.ClinicalImpression.date";
+    ClinicalImpressionParameters["FindingCode"] = "org.hl7.fhir.api.ClinicalImpression.finding-code";
+    ClinicalImpressionParameters["FindingRef"] = "org.hl7.fhir.api.ClinicalImpression.finding-ref";
+    ClinicalImpressionParameters["Identifier"] = "org.hl7.fhir.api.ClinicalImpression.identifier";
+    ClinicalImpressionParameters["Investigation"] = "org.hl7.fhir.api.ClinicalImpression.investigation";
+    ClinicalImpressionParameters["Patient"] = "org.hl7.fhir.api.ClinicalImpression.patient";
+    ClinicalImpressionParameters["Previous"] = "org.hl7.fhir.api.ClinicalImpression.previous";
+    ClinicalImpressionParameters["Problem"] = "org.hl7.fhir.api.ClinicalImpression.problem";
+    ClinicalImpressionParameters["Status"] = "org.hl7.fhir.api.ClinicalImpression.status";
+    ClinicalImpressionParameters["Support"] = "org.hl7.fhir.api.ClinicalImpression.support";
+    ClinicalImpressionParameters["Subject"] = "org.hl7.fhir.api.ClinicalImpression.subject";
+})(ClinicalImpressionParameters || (ClinicalImpressionParameters = {}));