@peerbits/fhir-validator 1.0.0 → 1.1.0

package/dist/base-definitions/coverage.js

@@ -0,0 +1,109 @@
+import { validateCodeableConcept } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+const VALID_COVERAGE_STATUSES = ["active", "cancelled", "draft", "entered-in-error"];
+/**
+ * Validates base structural rules for FHIR R4 Coverage resource.
+ */
+export function validateCoverage(resource, path = "Coverage") {
+    const issues = [];
+    if (resource.resourceType !== "Coverage") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'Coverage', found '${String(resource.resourceType)}'.`,
+        });
+    }
+    // status (Required)
+    if (resource.status === undefined || resource.status === null || resource.status === "") {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "required",
+            message: `Missing required 'status' in '${path}'.`,
+        });
+    }
+    else if (typeof resource.status !== "string" || !VALID_COVERAGE_STATUSES.includes(resource.status)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "invalid-value",
+            message: `Invalid Coverage status '${String(resource.status)}'. Allowed values: ${VALID_COVERAGE_STATUSES.join(", ")}.`,
+        });
+    }
+    // beneficiary (Required Reference: Patient)
+    if (resource.beneficiary === undefined || resource.beneficiary === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.beneficiary`,
+            code: "required",
+            message: `Missing required 'beneficiary' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateReference(resource.beneficiary, `${path}.beneficiary`, ["Patient"]));
+    }
+    // payor (Required Reference[]: Organization | Patient | RelatedPerson, min 1)
+    if (resource.payor === undefined || resource.payor === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.payor`,
+            code: "required",
+            message: `Missing required 'payor' in '${path}'.`,
+        });
+    }
+    else if (!Array.isArray(resource.payor)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.payor`,
+            code: "invalid-type",
+            message: `Expected '${path}.payor' to be an array, got ${typeof resource.payor}.`,
+        });
+    }
+    else if (resource.payor.length === 0) {
+        issues.push({
+            severity: "error",
+            path: `${path}.payor`,
+            code: "cardinality",
+            message: `Expected at least 1 payor in '${path}.payor', found 0.`,
+        });
+    }
+    else {
+        resource.payor.forEach((p, idx) => {
+            issues.push(...validateReference(p, `${path}.payor[${idx}]`, ["Organization", "Patient", "RelatedPerson"]));
+        });
+    }
+    // subscriber (Reference: Patient | RelatedPerson)
+    if (resource.subscriber !== undefined) {
+        issues.push(...validateReference(resource.subscriber, `${path}.subscriber`, ["Patient", "RelatedPerson"]));
+    }
+    // subscriberId (string)
+    if (resource.subscriberId !== undefined && typeof resource.subscriberId !== "string") {
+        issues.push({
+            severity: "error",
+            path: `${path}.subscriberId`,
+            code: "invalid-type",
+            message: `Expected '${path}.subscriberId' to be a string.`,
+        });
+    }
+    // type (CodeableConcept)
+    if (resource.type !== undefined) {
+        issues.push(...validateCodeableConcept(resource.type, `${path}.type`));
+    }
+    // relationship (CodeableConcept)
+    if (resource.relationship !== undefined) {
+        issues.push(...validateCodeableConcept(resource.relationship, `${path}.relationship`));
+    }
+    // period (Period)
+    if (resource.period !== undefined) {
+        if (typeof resource.period !== "object" || resource.period === null || Array.isArray(resource.period)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.period`,
+                code: "invalid-structure",
+                message: `Expected '${path}.period' to be an object.`,
+            });
+        }
+    }
+    return issues;
+}

package/dist/base-definitions/encounter.d.ts

@@ -0,0 +1,5 @@
+import { ValidationIssue } from "../types.js";
+/**
+ * Validates base structural rules for FHIR R4 Encounter resource.
+ */
+export declare function validateEncounter(resource: Record<string, unknown>, path?: string): ValidationIssue[];

package/dist/base-definitions/encounter.js

@@ -0,0 +1,137 @@
+import { validateCodeableConcept, validateCoding } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+const VALID_ENCOUNTER_STATUSES = [
+    "planned",
+    "arrived",
+    "triaged",
+    "in-progress",
+    "onleave",
+    "finished",
+    "cancelled",
+    "entered-in-error",
+    "unknown",
+];
+/**
+ * Validates base structural rules for FHIR R4 Encounter resource.
+ */
+export function validateEncounter(resource, path = "Encounter") {
+    const issues = [];
+    if (resource.resourceType !== "Encounter") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'Encounter', found '${String(resource.resourceType)}'.`,
+        });
+    }
+    // status (Required)
+    if (resource.status === undefined || resource.status === null || resource.status === "") {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "required",
+            message: `Missing required 'status' in '${path}'.`,
+        });
+    }
+    else if (typeof resource.status !== "string" || !VALID_ENCOUNTER_STATUSES.includes(resource.status)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "invalid-value",
+            message: `Invalid Encounter status '${String(resource.status)}'. Allowed values: ${VALID_ENCOUNTER_STATUSES.join(", ")}.`,
+        });
+    }
+    // class (Required Coding / Coding-like object)
+    if (resource.class === undefined || resource.class === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.class`,
+            code: "required",
+            message: `Missing required 'class' in '${path}'.`,
+        });
+    }
+    else {
+        // In FHIR R4, Encounter.class is a Coding
+        issues.push(...validateCoding(resource.class, `${path}.class`));
+    }
+    // subject (Reference: Patient | Group)
+    if (resource.subject !== undefined) {
+        issues.push(...validateReference(resource.subject, `${path}.subject`, ["Patient", "Group"]));
+    }
+    // period (Period)
+    if (resource.period !== undefined) {
+        if (typeof resource.period !== "object" || resource.period === null || Array.isArray(resource.period)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.period`,
+                code: "invalid-structure",
+                message: `Expected '${path}.period' to be an object.`,
+            });
+        }
+        else {
+            const p = resource.period;
+            if (p.start !== undefined && typeof p.start !== "string") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.period.start`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.period.start' to be a string.`,
+                });
+            }
+            if (p.end !== undefined && typeof p.end !== "string") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.period.end`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.period.end' to be a string.`,
+                });
+            }
+        }
+    }
+    // participant
+    if (resource.participant !== undefined) {
+        if (!Array.isArray(resource.participant)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.participant`,
+                code: "invalid-type",
+                message: `Expected '${path}.participant' to be an array.`,
+            });
+        }
+        else {
+            resource.participant.forEach((part, idx) => {
+                const partPath = `${path}.participant[${idx}]`;
+                if (typeof part !== "object" || part === null || Array.isArray(part)) {
+                    issues.push({
+                        severity: "error",
+                        path: partPath,
+                        code: "invalid-structure",
+                        message: `Expected '${partPath}' to be an object.`,
+                    });
+                }
+                else {
+                    const p = part;
+                    if (p.individual !== undefined) {
+                        issues.push(...validateReference(p.individual, `${partPath}.individual`, ["Practitioner", "PractitionerRole", "RelatedPerson"]));
+                    }
+                    if (p.type !== undefined && Array.isArray(p.type)) {
+                        p.type.forEach((t, tIdx) => {
+                            issues.push(...validateCodeableConcept(t, `${partPath}.type[${tIdx}]`));
+                        });
+                    }
+                }
+            });
+        }
+    }
+    // serviceProvider (Reference: Organization)
+    if (resource.serviceProvider !== undefined) {
+        issues.push(...validateReference(resource.serviceProvider, `${path}.serviceProvider`, ["Organization"]));
+    }
+    // type (CodeableConcept[])
+    if (resource.type !== undefined && Array.isArray(resource.type)) {
+        resource.type.forEach((t, idx) => {
+            issues.push(...validateCodeableConcept(t, `${path}.type[${idx}]`));
+        });
+    }
+    return issues;
+}

package/dist/base-definitions/observation.d.ts

@@ -0,0 +1,5 @@
+import { ValidationIssue } from "../types.js";
+/**
+ * Validates base structural rules for FHIR R4 Observation resource.
+ */
+export declare function validateObservation(resource: Record<string, unknown>, path?: string): ValidationIssue[];

package/dist/base-definitions/observation.js

@@ -0,0 +1,240 @@
+import { validateCodeableConcept } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+const VALID_OBSERVATION_STATUSES = [
+    "registered",
+    "preliminary",
+    "final",
+    "amended",
+    "corrected",
+    "cancelled",
+    "entered-in-error",
+    "unknown",
+];
+/**
+ * Validates base structural rules for FHIR R4 Observation resource.
+ */
+export function validateObservation(resource, path = "Observation") {
+    const issues = [];
+    const effectiveFields = ["effectiveDateTime", "effectivePeriod", "effectiveTiming", "effectiveInstant"].filter((field) => resource[field] !== undefined);
+    if (effectiveFields.length > 1)
+        issues.push({ severity: "error", path: `${path}.effective[x]`, code: "cardinality", message: "Observation may contain only one effective[x] value." });
+    const valueFields = ["valueQuantity", "valueCodeableConcept", "valueString", "valueBoolean", "valueInteger", "valueRange", "valueRatio", "valueSampledData", "valueTime", "valueDateTime", "valuePeriod"].filter((field) => resource[field] !== undefined);
+    if (valueFields.length > 1)
+        issues.push({ severity: "error", path: `${path}.value[x]`, code: "cardinality", message: "Observation may contain only one value[x] value." });
+    if (resource.resourceType !== "Observation") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'Observation', found '${String(resource.resourceType)}'.`,
+        });
+    }
+    // status (Required)
+    if (resource.status === undefined || resource.status === null || resource.status === "") {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "required",
+            message: `Missing required 'status' in '${path}'.`,
+        });
+    }
+    else if (typeof resource.status !== "string" || !VALID_OBSERVATION_STATUSES.includes(resource.status)) {
+        issues.push({
+            severity: "error",
+            path: `${path}.status`,
+            code: "invalid-value",
+            message: `Invalid Observation status '${String(resource.status)}'. Allowed values: ${VALID_OBSERVATION_STATUSES.join(", ")}.`,
+        });
+    }
+    // code (Required CodeableConcept)
+    if (resource.code === undefined || resource.code === null) {
+        issues.push({
+            severity: "error",
+            path: `${path}.code`,
+            code: "required",
+            message: `Missing required 'code' in '${path}'.`,
+        });
+    }
+    else {
+        issues.push(...validateCodeableConcept(resource.code, `${path}.code`, { requireCoding: true }));
+    }
+    // category (CodeableConcept[])
+    if (resource.category !== undefined) {
+        if (!Array.isArray(resource.category)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.category`,
+                code: "invalid-type",
+                message: `Expected '${path}.category' to be an array, got ${typeof resource.category}.`,
+            });
+        }
+        else {
+            resource.category.forEach((cat, idx) => {
+                issues.push(...validateCodeableConcept(cat, `${path}.category[${idx}]`));
+            });
+        }
+    }
+    // subject (Reference: Patient | Group | Device | Location)
+    if (resource.subject !== undefined) {
+        issues.push(...validateReference(resource.subject, `${path}.subject`, ["Patient", "Group", "Device", "Location"]));
+    }
+    // encounter (Reference: Encounter)
+    if (resource.encounter !== undefined) {
+        issues.push(...validateReference(resource.encounter, `${path}.encounter`, ["Encounter"]));
+    }
+    // performer (Reference[])
+    if (resource.performer !== undefined) {
+        if (!Array.isArray(resource.performer)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.performer`,
+                code: "invalid-type",
+                message: `Expected '${path}.performer' to be an array, got ${typeof resource.performer}.`,
+            });
+        }
+        else {
+            resource.performer.forEach((perf, idx) => {
+                issues.push(...validateReference(perf, `${path}.performer[${idx}]`, ["Practitioner", "PractitionerRole", "Organization", "CareTeam", "Patient", "RelatedPerson"]));
+            });
+        }
+    }
+    // valueQuantity
+    if (resource.valueQuantity !== undefined) {
+        if (typeof resource.valueQuantity !== "object" || resource.valueQuantity === null || Array.isArray(resource.valueQuantity)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.valueQuantity`,
+                code: "invalid-structure",
+                message: `Expected '${path}.valueQuantity' to be an object.`,
+            });
+        }
+        else {
+            const q = resource.valueQuantity;
+            if (q.value !== undefined && (typeof q.value !== "number" || !Number.isFinite(q.value))) {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.valueQuantity.value`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.valueQuantity.value' to be a number, got ${typeof q.value}.`,
+                });
+            }
+            if (q.unit !== undefined && typeof q.unit !== "string") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.valueQuantity.unit`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.valueQuantity.unit' to be a string.`,
+                });
+            }
+            if (q.system !== undefined && typeof q.system !== "string") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.valueQuantity.system`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.valueQuantity.system' to be a string.`,
+                });
+            }
+            if (q.code !== undefined && typeof q.code !== "string") {
+                issues.push({
+                    severity: "error",
+                    path: `${path}.valueQuantity.code`,
+                    code: "invalid-type",
+                    message: `Expected '${path}.valueQuantity.code' to be a string.`,
+                });
+            }
+            if (q.system !== undefined && q.system === "http://unitsofmeasure.org" && (typeof q.code !== "string" || !q.code.trim())) {
+                issues.push({ severity: "error", path: `${path}.valueQuantity.code`, code: "required", message: "UCUM Quantity requires a non-empty code." });
+            }
+        }
+    }
+    if (resource.effectiveDateTime !== undefined && (typeof resource.effectiveDateTime !== "string" || Number.isNaN(Date.parse(resource.effectiveDateTime)))) {
+        issues.push({ severity: "error", path: `${path}.effectiveDateTime`, code: "invalid-value", message: "effectiveDateTime must be a valid date-time string." });
+    }
+    if (resource.effectivePeriod !== undefined) {
+        if (!resource.effectivePeriod || typeof resource.effectivePeriod !== "object" || Array.isArray(resource.effectivePeriod)) {
+            issues.push({ severity: "error", path: `${path}.effectivePeriod`, code: "invalid-structure", message: "effectivePeriod must be an object." });
+        }
+        else {
+            const period = resource.effectivePeriod;
+            const start = typeof period.start === "string" ? Date.parse(period.start) : NaN;
+            const end = typeof period.end === "string" ? Date.parse(period.end) : NaN;
+            if (Number.isNaN(start) || Number.isNaN(end) || start > end)
+                issues.push({ severity: "error", path: `${path}.effectivePeriod`, code: "invalid-value", message: "effectivePeriod requires valid start and end values in chronological order." });
+        }
+    }
+    // valueCodeableConcept
+    if (resource.valueCodeableConcept !== undefined) {
+        issues.push(...validateCodeableConcept(resource.valueCodeableConcept, `${path}.valueCodeableConcept`));
+    }
+    // component (Array of components)
+    if (resource.component !== undefined) {
+        if (!Array.isArray(resource.component)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.component`,
+                code: "invalid-type",
+                message: `Expected '${path}.component' to be an array, got ${typeof resource.component}.`,
+            });
+        }
+        else {
+            resource.component.forEach((comp, idx) => {
+                const compPath = `${path}.component[${idx}]`;
+                if (typeof comp !== "object" || comp === null || Array.isArray(comp)) {
+                    issues.push({
+                        severity: "error",
+                        path: compPath,
+                        code: "invalid-structure",
+                        message: `Expected '${compPath}' to be an object.`,
+                    });
+                }
+                else {
+                    const c = comp;
+                    if (c.code === undefined || c.code === null) {
+                        issues.push({
+                            severity: "error",
+                            path: `${compPath}.code`,
+                            code: "required",
+                            message: `Missing required 'code' in '${compPath}'.`,
+                        });
+                    }
+                    else {
+                        issues.push(...validateCodeableConcept(c.code, `${compPath}.code`, { requireCoding: true }));
+                    }
+                    if (c.valueQuantity !== undefined) {
+                        const q = c.valueQuantity;
+                        if (!q || Array.isArray(q)) {
+                            issues.push({ severity: "error", path: `${compPath}.valueQuantity`, code: "invalid-structure", message: `Expected '${compPath}.valueQuantity' to be an object.` });
+                        }
+                        else if (typeof q.value !== "number" || !Number.isFinite(q.value)) {
+                            issues.push({
+                                severity: "error",
+                                path: `${compPath}.valueQuantity.value`,
+                                code: "invalid-type",
+                                message: `Expected '${compPath}.valueQuantity.value' to be a number.`,
+                            });
+                        }
+                    }
+                    if (c.valueCodeableConcept !== undefined) {
+                        issues.push(...validateCodeableConcept(c.valueCodeableConcept, `${compPath}.valueCodeableConcept`));
+                    }
+                }
+            });
+        }
+    }
+    // hasMember / derivedFrom
+    if (resource.hasMember !== undefined) {
+        if (Array.isArray(resource.hasMember)) {
+            resource.hasMember.forEach((hm, idx) => {
+                issues.push(...validateReference(hm, `${path}.hasMember[${idx}]`, ["Observation", "QuestionnaireResponse", "MolecularSequence"]));
+            });
+        }
+    }
+    if (resource.derivedFrom !== undefined) {
+        if (Array.isArray(resource.derivedFrom)) {
+            resource.derivedFrom.forEach((df, idx) => {
+                issues.push(...validateReference(df, `${path}.derivedFrom[${idx}]`, ["DocumentReference", "ImagingStudy", "Media", "QuestionnaireResponse", "Observation", "MolecularSequence"]));
+            });
+        }
+    }
+    return issues;
+}

package/dist/base-definitions/patient.d.ts

@@ -0,0 +1,5 @@
+import { ValidationIssue } from "../types.js";
+/**
+ * Validates base structural rules for FHIR R4 Patient resource.
+ */
+export declare function validatePatient(resource: Record<string, unknown>, path?: string): ValidationIssue[];

package/dist/base-definitions/patient.js

@@ -0,0 +1,163 @@
+import { validateCodeableConcept } from "../coding.js";
+import { validateReference } from "../reference-rules.js";
+const VALID_GENDERS = ["male", "female", "other", "unknown"];
+const DATE_REGEX = /^\d{4}(-\d{2}(-\d{2})?)?$/;
+/**
+ * Validates base structural rules for FHIR R4 Patient resource.
+ */
+export function validatePatient(resource, path = "Patient") {
+    const issues = [];
+    if (resource.resourceType !== "Patient") {
+        issues.push({
+            severity: "error",
+            path: `${path}.resourceType`,
+            code: "invalid-resource-type",
+            message: `Expected resourceType 'Patient', found '${String(resource.resourceType)}'.`,
+        });
+    }
+    // active
+    if (resource.active !== undefined && typeof resource.active !== "boolean") {
+        issues.push({
+            severity: "error",
+            path: `${path}.active`,
+            code: "invalid-type",
+            message: `Expected '${path}.active' to be a boolean, got ${typeof resource.active}.`,
+        });
+    }
+    // gender
+    if (resource.gender !== undefined) {
+        if (typeof resource.gender !== "string" || !VALID_GENDERS.includes(resource.gender)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.gender`,
+                code: "invalid-value",
+                message: `Invalid gender '${String(resource.gender)}'. Allowed values: ${VALID_GENDERS.join(", ")}.`,
+            });
+        }
+    }
+    // birthDate
+    if (resource.birthDate !== undefined) {
+        if (typeof resource.birthDate !== "string" || !DATE_REGEX.test(resource.birthDate)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.birthDate`,
+                code: "invalid-format",
+                message: `Expected '${path}.birthDate' to match YYYY, YYYY-MM, or YYYY-MM-DD format.`,
+            });
+        }
+    }
+    // name (HumanName[])
+    if (resource.name !== undefined) {
+        if (!Array.isArray(resource.name)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.name`,
+                code: "invalid-type",
+                message: `Expected '${path}.name' to be an array, got ${typeof resource.name}.`,
+            });
+        }
+        else {
+            resource.name.forEach((n, idx) => {
+                const namePath = `${path}.name[${idx}]`;
+                if (typeof n !== "object" || n === null) {
+                    issues.push({
+                        severity: "error",
+                        path: namePath,
+                        code: "invalid-structure",
+                        message: `Expected '${namePath}' to be a HumanName object.`,
+                    });
+                }
+                else {
+                    const hn = n;
+                    if (hn.family !== undefined && typeof hn.family !== "string") {
+                        issues.push({
+                            severity: "error",
+                            path: `${namePath}.family`,
+                            code: "invalid-type",
+                            message: `Expected '${namePath}.family' to be a string.`,
+                        });
+                    }
+                    if (hn.given !== undefined && (!Array.isArray(hn.given) || hn.given.some((g) => typeof g !== "string"))) {
+                        issues.push({
+                            severity: "error",
+                            path: `${namePath}.given`,
+                            code: "invalid-type",
+                            message: `Expected '${namePath}.given' to be an array of strings.`,
+                        });
+                    }
+                }
+            });
+        }
+    }
+    // identifier (Identifier[])
+    if (resource.identifier !== undefined) {
+        if (!Array.isArray(resource.identifier)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.identifier`,
+                code: "invalid-type",
+                message: `Expected '${path}.identifier' to be an array, got ${typeof resource.identifier}.`,
+            });
+        }
+        else {
+            resource.identifier.forEach((ident, idx) => {
+                const idPath = `${path}.identifier[${idx}]`;
+                if (typeof ident !== "object" || ident === null) {
+                    issues.push({
+                        severity: "error",
+                        path: idPath,
+                        code: "invalid-structure",
+                        message: `Expected '${idPath}' to be an Identifier object.`,
+                    });
+                }
+                else {
+                    const idObj = ident;
+                    if (idObj.system !== undefined && typeof idObj.system !== "string") {
+                        issues.push({
+                            severity: "error",
+                            path: `${idPath}.system`,
+                            code: "invalid-type",
+                            message: `Expected '${idPath}.system' to be a string.`,
+                        });
+                    }
+                    if (idObj.value !== undefined && typeof idObj.value !== "string") {
+                        issues.push({
+                            severity: "error",
+                            path: `${idPath}.value`,
+                            code: "invalid-type",
+                            message: `Expected '${idPath}.value' to be a string.`,
+                        });
+                    }
+                    if (idObj.type !== undefined) {
+                        issues.push(...validateCodeableConcept(idObj.type, `${idPath}.type`));
+                    }
+                }
+            });
+        }
+    }
+    // generalPractitioner (Reference[])
+    if (resource.generalPractitioner !== undefined) {
+        if (!Array.isArray(resource.generalPractitioner)) {
+            issues.push({
+                severity: "error",
+                path: `${path}.generalPractitioner`,
+                code: "invalid-type",
+                message: `Expected '${path}.generalPractitioner' to be an array.`,
+            });
+        }
+        else {
+            resource.generalPractitioner.forEach((gp, idx) => {
+                issues.push(...validateReference(gp, `${path}.generalPractitioner[${idx}]`, ["Organization", "Practitioner", "PractitionerRole"]));
+            });
+        }
+    }
+    // managingOrganization (Reference)
+    if (resource.managingOrganization !== undefined) {
+        issues.push(...validateReference(resource.managingOrganization, `${path}.managingOrganization`, ["Organization"]));
+    }
+    // maritalStatus (CodeableConcept)
+    if (resource.maritalStatus !== undefined) {
+        issues.push(...validateCodeableConcept(resource.maritalStatus, `${path}.maritalStatus`));
+    }
+    return issues;
+}