@imranq2/fhirpatientsummary 1.0.0 → 1.0.2

package/lib/esm/src/generators/fhir_summary_generator.d.ts

@@ -0,0 +1,46 @@
+import { TPatient } from "../types/resources/Patient";
+import { TCompositionSection } from "../types/partials/CompositionSection";
+import { TDomainResource } from "../types/resources/DomainResource";
+import { IPSSections } from "../structures/ips_sections";
+import { TBundle } from "../types/resources/Bundle";
+export declare class ComprehensiveIPSCompositionBuilder {
+    private patient;
+    private sections;
+    private mandatorySectionsAdded;
+    private resources;
+    /**
+     * sets the patient resource for the IPS Composition.
+     * This is not needed if you are calling read_bundle, but can be used to set the patient resource directly.
+     * @param patient - FHIR Patient resource to set
+     */
+    setPatient(patient: TPatient): this;
+    addSection<T extends TDomainResource>(sectionType: IPSSections, resources: T[], timezone: string | undefined, options?: {
+        isOptional?: boolean;
+        customLoincCode?: string;
+    }): this;
+    /**
+     * Reads a FHIR Bundle and extracts resources for each section defined in IPSSections.
+     * @param bundle - FHIR Bundle containing resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     */
+    read_bundle(bundle: TBundle, timezone: string | undefined): this;
+    /**
+     * Builds the final Composition sections, ensuring all mandatory sections are present.
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     */
+    build(timezone: string | undefined): TCompositionSection[];
+    /**
+     * Builds a complete FHIR Bundle containing the Composition and all resources.
+     * @param authorOrganizationId - ID of the authoring organization (e.g., hospital or clinic)
+     * @param authorOrganizationName - Name of the authoring organization
+     * @param baseUrl - Base URL for the FHIR server (e.g., 'https://example.com/fhir')
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     */
+    build_bundle(authorOrganizationId: string, authorOrganizationName: string, baseUrl: string, timezone: string | undefined): TBundle;
+    /**
+     * Creates a narrative for the composition based on the patient and sections.
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @private
+     */
+    private createCompositionNarrative;
+}

package/lib/esm/src/generators/fhir_summary_generator.js

@@ -0,0 +1,224 @@
+import { IPSSections } from "../structures/ips_sections";
+import { IPS_SECTION_DISPLAY_NAMES, IPS_SECTION_LOINC_CODES } from "../structures/ips_section_loinc_codes";
+import { IPSSectionResourceHelper } from "../structures/ips_section_resource_map";
+import { NarrativeGenerator } from "./narrative_generator";
+export class ComprehensiveIPSCompositionBuilder {
+    constructor() {
+        this.sections = [];
+        this.mandatorySectionsAdded = new Set();
+        this.resources = new Set();
+    }
+    /**
+     * sets the patient resource for the IPS Composition.
+     * This is not needed if you are calling read_bundle, but can be used to set the patient resource directly.
+     * @param patient - FHIR Patient resource to set
+     */
+    setPatient(patient) {
+        if (!patient || patient.resourceType !== 'Patient') {
+            throw new Error('Invalid Patient resource');
+        }
+        this.patient = patient;
+        return this;
+    }
+    // Comprehensive method to add sections with validation
+    addSection(sectionType, resources, timezone, options) {
+        // Validate resources
+        const validResources = resources;
+        for (const resource of validResources) {
+            // Add resource to the internal set
+            this.resources.add(resource);
+        }
+        // Skip if no valid resources and not mandatory
+        if (validResources.length === 0) {
+            if (!(options === null || options === void 0 ? void 0 : options.isOptional)) {
+                throw new Error(`No valid resources for mandatory section: ${sectionType}`);
+            }
+            return this;
+        }
+        // Patient resource does not get a section, it is handled separately
+        if (sectionType !== IPSSections.PATIENT) {
+            // Create section entry
+            const narrative = NarrativeGenerator.generateNarrative(sectionType, validResources, timezone);
+            const sectionEntry = {
+                title: IPS_SECTION_DISPLAY_NAMES[sectionType] || sectionType,
+                code: {
+                    coding: [{
+                            system: 'http://loinc.org',
+                            code: (options === null || options === void 0 ? void 0 : options.customLoincCode) || IPS_SECTION_LOINC_CODES[sectionType],
+                            display: IPS_SECTION_DISPLAY_NAMES[sectionType] || sectionType
+                        }],
+                    text: IPS_SECTION_DISPLAY_NAMES[sectionType] || sectionType
+                },
+                text: narrative,
+                entry: validResources.map(resource => ({
+                    reference: `${resource.resourceType}/${resource.id}`,
+                    display: resource.resourceType
+                }))
+            };
+            // Track mandatory sections
+            if (!(options === null || options === void 0 ? void 0 : options.isOptional)) {
+                this.mandatorySectionsAdded.add(sectionType);
+            }
+            this.sections.push(sectionEntry);
+        }
+        return this;
+    }
+    /**
+     * Reads a FHIR Bundle and extracts resources for each section defined in IPSSections.
+     * @param bundle - FHIR Bundle containing resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     */
+    read_bundle(bundle, timezone) {
+        if (!bundle.entry) {
+            return this;
+        }
+        // find the patient resource in the bundle
+        const patientEntry = bundle.entry.find(e => { var _a; return ((_a = e.resource) === null || _a === void 0 ? void 0 : _a.resourceType) === 'Patient'; });
+        if (!patientEntry || !patientEntry.resource) {
+            throw new Error('Patient resource not found in the bundle');
+        }
+        this.patient = patientEntry.resource;
+        // find resources for each section in IPSSections and add the section
+        for (const sectionType of Object.values(IPSSections)) {
+            const resourceTypesForSection = IPSSectionResourceHelper.getResourceTypesForSection(sectionType);
+            const customFilter = IPSSectionResourceHelper.getResourceFilterForSection(sectionType);
+            let resources = bundle.entry
+                .map(e => e.resource)
+                .filter(r => typeof (r === null || r === void 0 ? void 0 : r.resourceType) === 'string' && resourceTypesForSection.includes(r.resourceType));
+            if (customFilter) {
+                resources = resources.filter(customFilter);
+            }
+            if (resources.length > 0) {
+                this.addSection(sectionType, resources, timezone, { isOptional: true });
+            }
+        }
+        return this;
+    }
+    /**
+     * Builds the final Composition sections, ensuring all mandatory sections are present.
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    build(timezone) {
+        // Ensure all mandatory sections are present
+        const mandatorySections = [
+            IPSSections.ALLERGIES,
+            IPSSections.MEDICATIONS,
+            IPSSections.PROBLEMS,
+            IPSSections.IMMUNIZATIONS
+        ];
+        const missingMandatorySections = mandatorySections.filter(section => !this.mandatorySectionsAdded.has(section));
+        if (missingMandatorySections.length > 0) {
+            throw new Error(`Missing mandatory IPS sections: ${missingMandatorySections.join(', ')}`);
+        }
+        return this.sections;
+    }
+    /**
+     * Builds a complete FHIR Bundle containing the Composition and all resources.
+     * @param authorOrganizationId - ID of the authoring organization (e.g., hospital or clinic)
+     * @param authorOrganizationName - Name of the authoring organization
+     * @param baseUrl - Base URL for the FHIR server (e.g., 'https://example.com/fhir')
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     */
+    build_bundle(authorOrganizationId, authorOrganizationName, baseUrl, timezone) {
+        var _a, _b, _c;
+        if (baseUrl.endsWith('/')) {
+            baseUrl = baseUrl.slice(0, -1); // Remove trailing slash if present
+        }
+        if (!this.patient) {
+            throw new Error('Patient resource must be set before building the bundle');
+        }
+        // Create the Composition resource
+        const composition = {
+            id: `Composition-${this.patient.id}`,
+            resourceType: 'Composition',
+            status: 'final',
+            type: {
+                coding: [{
+                        system: 'http://loinc.org',
+                        code: '60591-5',
+                        display: 'Patient summary Document'
+                    }]
+            },
+            subject: {
+                reference: `Patient/${this.patient.id}`
+            },
+            author: [{
+                    reference: `Organization/${authorOrganizationId}`, // Assuming patient is also a practitioner for simplicity
+                    display: authorOrganizationName
+                }],
+            date: new Date().toISOString(),
+            title: 'International Patient Summary',
+            section: this.sections,
+            text: this.createCompositionNarrative(timezone)
+        };
+        // Create the bundle with proper document type
+        const bundle = {
+            resourceType: 'Bundle',
+            type: 'document',
+            timestamp: new Date().toISOString(),
+            identifier: {
+                "system": "urn:ietf:rfc:3986",
+                "value": "urn:uuid:4dcfd353-49fd-4ab0-b521-c8d57ced74d6"
+            },
+            entry: []
+        };
+        // Add Composition as first entry
+        (_a = bundle.entry) === null || _a === void 0 ? void 0 : _a.push({
+            fullUrl: `${baseUrl}/Composition/${composition.id}`,
+            resource: composition
+        });
+        // Add patient as second entry
+        (_b = bundle.entry) === null || _b === void 0 ? void 0 : _b.push({
+            fullUrl: `${baseUrl}/Patient/${this.patient.id}`,
+            resource: this.patient
+        });
+        // Extract and add all resources referenced in sections
+        this.resources.forEach(resource => {
+            var _a;
+            if (resource.resourceType !== "Patient") {
+                (_a = bundle.entry) === null || _a === void 0 ? void 0 : _a.push({
+                    fullUrl: `${baseUrl}/${resource.resourceType}/${resource.id}`,
+                    resource: resource
+                });
+            }
+        });
+        // add a bundle entry for Organization
+        (_c = bundle.entry) === null || _c === void 0 ? void 0 : _c.push({
+            fullUrl: `${baseUrl}/Organization/${authorOrganizationId}`,
+            resource: {
+                resourceType: 'Organization',
+                id: authorOrganizationId,
+                name: authorOrganizationName
+            }
+        });
+        return bundle;
+    }
+    /**
+     * Creates a narrative for the composition based on the patient and sections.
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @private
+     */
+    createCompositionNarrative(timezone) {
+        const patient = this.patient;
+        let fullNarrativeContent = "";
+        // generate narrative for the patient
+        const patientNarrative = NarrativeGenerator.generateNarrativeContent(IPSSections.PATIENT, [patient], timezone);
+        fullNarrativeContent = fullNarrativeContent.concat(patientNarrative || '');
+        // now generate narrative for the sections and add to this narrative
+        for (const sectionType of Object.values(IPSSections)) {
+            const resourceTypesForSection = IPSSectionResourceHelper.getResourceTypesForSection(sectionType);
+            const allResources = Array.from(this.resources);
+            const resources = allResources
+                .filter(r => resourceTypesForSection.includes(r.resourceType));
+            if (resources.length > 0) {
+                const sectionNarrative = NarrativeGenerator.generateNarrativeContent(sectionType, resources, timezone);
+                fullNarrativeContent = fullNarrativeContent.concat(sectionNarrative || '');
+            }
+        }
+        return {
+            status: 'generated',
+            div: NarrativeGenerator.wrapInXhtml(fullNarrativeContent)
+        };
+    }
+}

package/lib/esm/src/generators/narrative_generator.d.ts

@@ -0,0 +1,40 @@
+import { TDomainResource } from "../types/resources/DomainResource";
+import { IPSSections } from "../structures/ips_sections";
+export interface Narrative {
+    status: 'generated' | 'extensions' | 'additional' | 'empty';
+    div: string;
+}
+/**
+ * Generates narrative content for FHIR resources using TypeScript templates
+ * Replaces the Nunjucks-based narrative generator
+ */
+export declare class NarrativeGenerator {
+    /**
+     * Generates narrative HTML content for a section
+     * @param section - IPS section type
+     * @param resources - Array of domain resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns Generated HTML content or undefined if no resources
+     */
+    static generateNarrativeContent<T extends TDomainResource>(section: IPSSections, resources: T[], timezone: string | undefined): string | undefined;
+    /**
+     * Creates a complete FHIR Narrative object
+     * @param content - HTML content
+     * @returns FHIR Narrative object
+     */
+    static createNarrative(content: string): Narrative;
+    /**
+     * Generates a complete FHIR Narrative object for a section
+     * @param section - IPS section type
+     * @param resources - Array of domain resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns FHIR Narrative object or undefined if no resources
+     */
+    static generateNarrative<T extends TDomainResource>(section: IPSSections, resources: T[], timezone: string | undefined): Narrative | undefined;
+    /**
+     * Wrap content in XHTML div with FHIR namespace
+     * @param content - HTML content to wrap
+     * @returns XHTML div string
+     */
+    static wrapInXhtml(content: string): string;
+}

package/lib/esm/src/generators/narrative_generator.js

@@ -0,0 +1,76 @@
+// TypeScriptNarrativeGenerator.ts - TypeScript replacement for narrative_generator.ts using TypeScript templates
+import { TypeScriptTemplateMapper } from "../narratives/templates/typescript/TypeScriptTemplateMapper";
+/**
+ * Generates narrative content for FHIR resources using TypeScript templates
+ * Replaces the Nunjucks-based narrative generator
+ */
+export class NarrativeGenerator {
+    /**
+     * Generates narrative HTML content for a section
+     * @param section - IPS section type
+     * @param resources - Array of domain resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns Generated HTML content or undefined if no resources
+     */
+    static generateNarrativeContent(section, resources, timezone) {
+        if (!resources || resources.length === 0) {
+            return undefined; // No resources to generate narrative
+        }
+        try {
+            // Create a bundle-like structure for the template
+            const bundle = {
+                resourceType: 'Bundle',
+                type: 'collection',
+                entry: resources.map(resource => ({
+                    resource
+                }))
+            };
+            // Use the TypeScript template mapper to generate HTML
+            return TypeScriptTemplateMapper.generateNarrative(section, bundle, timezone);
+        }
+        catch (error) {
+            console.error(`Error generating narrative for section ${section}:`, error);
+            return `<div class="error">Error generating narrative: ${error instanceof Error ? error.message : String(error)}</div>`;
+        }
+    }
+    /**
+     * Creates a complete FHIR Narrative object
+     * @param content - HTML content
+     * @returns FHIR Narrative object
+     */
+    static createNarrative(content) {
+        // remove extra whitespace and newlines
+        content = content.replace(/\s+/g, ' ').trim();
+        // Strip outer <div> wrappers if present
+        const divMatch = content.match(/^<div[^>]*>(.*?)<\/div>$/);
+        if (divMatch) {
+            content = divMatch[1]; // Extract inner content
+        }
+        return {
+            status: 'generated',
+            div: `<div xmlns="http://www.w3.org/1999/xhtml">${content}</div>`
+        };
+    }
+    /**
+     * Generates a complete FHIR Narrative object for a section
+     * @param section - IPS section type
+     * @param resources - Array of domain resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns FHIR Narrative object or undefined if no resources
+     */
+    static generateNarrative(section, resources, timezone) {
+        const content = this.generateNarrativeContent(section, resources, timezone);
+        if (!content) {
+            return undefined;
+        }
+        return this.createNarrative(content);
+    }
+    /**
+     * Wrap content in XHTML div with FHIR namespace
+     * @param content - HTML content to wrap
+     * @returns XHTML div string
+     */
+    static wrapInXhtml(content) {
+        return `<div xmlns="http://www.w3.org/1999/xhtml">${content}</div>`;
+    }
+}

package/lib/esm/src/narratives/templates/typescript/AdvanceDirectivesTemplate.d.ts

@@ -0,0 +1,22 @@
+import { TBundle } from '../../../types/resources/Bundle';
+import { ITemplate } from './interfaces/ITemplate';
+/**
+ * Class to generate HTML narrative for Advance Directives (Consent resources)
+ * This replaces the Jinja2 advancedirectives.j2 template
+ */
+export declare class AdvanceDirectivesTemplate implements ITemplate {
+    /**
+     * Generate HTML narrative for Advance Directives
+     * @param resource - FHIR Bundle containing Advance Directive resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns HTML string for rendering
+     */
+    generateNarrative(resource: TBundle, timezone: string | undefined): string;
+    /**
+     * Internal static implementation that actually generates the narrative
+     * @param resource - FHIR Bundle containing Advance Directive resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns HTML string for rendering
+     */
+    private static generateStaticNarrative;
+}

package/lib/esm/src/narratives/templates/typescript/AdvanceDirectivesTemplate.js

@@ -0,0 +1,66 @@
+// AdvanceDirectivesTemplate.ts - TypeScript replacement for Jinja2 advancedirectives.j2
+import { TemplateUtilities } from './TemplateUtilities';
+/**
+ * Class to generate HTML narrative for Advance Directives (Consent resources)
+ * This replaces the Jinja2 advancedirectives.j2 template
+ */
+export class AdvanceDirectivesTemplate {
+    /**
+     * Generate HTML narrative for Advance Directives
+     * @param resource - FHIR Bundle containing Advance Directive resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns HTML string for rendering
+     */
+    generateNarrative(resource, timezone) {
+        return AdvanceDirectivesTemplate.generateStaticNarrative(resource, timezone);
+    }
+    /**
+     * Internal static implementation that actually generates the narrative
+     * @param resource - FHIR Bundle containing Advance Directive resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns HTML string for rendering
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static generateStaticNarrative(resource, timezone) {
+        var _a;
+        const templateUtilities = new TemplateUtilities(resource);
+        // Start building the HTML table
+        let html = `
+      <h5>Advance Directives</h5>
+      <table class="hapiPropertyTable">
+        <thead>
+          <tr>
+            <th>Scope</th>
+            <th>Status</th>
+            <th>Action Controlled</th>
+            <th>Date</th>
+          </tr>
+        </thead>
+        <tbody>`;
+        // Check if we have entries in the bundle
+        if (resource.entry && Array.isArray(resource.entry)) {
+            // Loop through entries in the bundle
+            for (const entry of resource.entry) {
+                const consent = entry.resource;
+                // Skip Composition resources
+                if (consent.resourceType === 'Composition') {
+                    continue;
+                }
+                // Use the enhanced narrativeLinkId utility function to extract the ID
+                // Add a table row for this consent
+                html += `
+          <tr id="${(templateUtilities.narrativeLinkId(consent))}">
+            <td>${templateUtilities.codeableConcept(consent.scope, 'display')}</td>
+            <td>${consent.status || ''}</td>
+            <td>${((_a = consent.provision) === null || _a === void 0 ? void 0 : _a.action) ? templateUtilities.concatCodeableConcept(consent.provision.action) : ''}</td>
+            <td>${consent.dateTime || ''}</td>
+          </tr>`;
+            }
+        }
+        // Close the HTML table
+        html += `
+        </tbody>
+      </table>`;
+        return html;
+    }
+}

package/lib/esm/src/narratives/templates/typescript/AllergyIntoleranceTemplate.d.ts

@@ -0,0 +1,31 @@
+import { TBundle } from '../../../types/resources/Bundle';
+import { ITemplate } from './interfaces/ITemplate';
+/**
+ * Class to generate HTML narrative for AllergyIntolerance resources
+ * This replaces the Jinja2 allergyintolerance.j2 template
+ */
+export declare class AllergyIntoleranceTemplate implements ITemplate {
+    /**
+     * Generate HTML narrative for AllergyIntolerance resources
+     * @param resource - FHIR Bundle containing AllergyIntolerance resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns HTML string for rendering
+     */
+    generateNarrative(resource: TBundle, timezone: string | undefined): string;
+    /**
+     * Internal static implementation that actually generates the narrative
+     * @param resource - FHIR Bundle containing AllergyIntolerance resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns HTML string for rendering
+     */
+    private static generateStaticNarrative;
+    /**
+     * Helper method to generate HTML table rows for allergies
+     * @param allergies - Array of allergy resources to process
+     * @param templateUtilities - Utilities for formatting
+     * @param includeResolved - Whether to include resolved date column
+     * @param timezone - Optional timezone to use for date formatting
+     * @returns HTML string with table rows
+     */
+    private static generateAllergyRows;
+}

package/lib/esm/src/narratives/templates/typescript/AllergyIntoleranceTemplate.js

@@ -0,0 +1,151 @@
+// AllergyIntoleranceTemplate.ts - TypeScript replacement for Jinja2 allergyintolerance.j2
+import { TemplateUtilities } from './TemplateUtilities';
+/**
+ * Class to generate HTML narrative for AllergyIntolerance resources
+ * This replaces the Jinja2 allergyintolerance.j2 template
+ */
+export class AllergyIntoleranceTemplate {
+    /**
+     * Generate HTML narrative for AllergyIntolerance resources
+     * @param resource - FHIR Bundle containing AllergyIntolerance resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns HTML string for rendering
+     */
+    generateNarrative(resource, timezone) {
+        return AllergyIntoleranceTemplate.generateStaticNarrative(resource, timezone);
+    }
+    /**
+     * Internal static implementation that actually generates the narrative
+     * @param resource - FHIR Bundle containing AllergyIntolerance resources
+     * @param timezone - Optional timezone to use for date formatting (e.g., 'America/New_York', 'Europe/London')
+     * @returns HTML string for rendering
+     */
+    static generateStaticNarrative(resource, timezone) {
+        var _a, _b, _c;
+        const templateUtilities = new TemplateUtilities(resource);
+        // Group allergies by status (active vs resolved/inactive)
+        const activeAllergies = [];
+        const resolvedAllergies = [];
+        if (resource.entry && Array.isArray(resource.entry)) {
+            for (const entry of resource.entry) {
+                const allergy = entry.resource;
+                // Check clinical status to determine if active or resolved
+                const status = ((_c = (_b = (_a = allergy.clinicalStatus) === null || _a === void 0 ? void 0 : _a.coding) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.code) || '';
+                if (status === 'inactive' || status === 'resolved') {
+                    resolvedAllergies.push(allergy);
+                }
+                else {
+                    activeAllergies.push(allergy);
+                }
+            }
+        }
+        // Start building the HTML with proper XHTML namespace
+        let html = `<div xmlns="http://www.w3.org/1999/xhtml">`;
+        // Active Allergies section
+        html += `
+      <div class="ActiveAllergies">
+        <h3>Active Allergies and Intolerances</h3>
+        <table class="ActiveAllergyTable">
+          <thead>
+            <tr>
+              <th>Allergen</th>
+              <th>Status</th>
+              <th>Category</th>
+              <th>Reaction</th>
+              <th>Severity</th>
+              <th>Onset Date</th>
+              <th>Comments</th>
+            </tr>
+          </thead>
+          <tbody>`;
+        // Process active allergies
+        if (activeAllergies.length > 0) {
+            html += this.generateAllergyRows(activeAllergies, templateUtilities, timezone);
+        }
+        else {
+            html += `
+          <tr>
+            <td colspan="7">No active allergies recorded</td>
+          </tr>`;
+        }
+        // Close the active allergies table
+        html += `
+          </tbody>
+        </table>
+      </div>`;
+        // Resolved Allergies section
+        html += `
+      <div class="ResolvedAllergies">
+        <h3>Resolved Allergies and Intolerances</h3>
+        <table class="ResolvedAllergyTable">
+          <thead>
+            <tr>
+              <th>Allergen</th>
+              <th>Status</th>
+              <th>Category</th>
+              <th>Reaction</th>
+              <th>Severity</th>
+              <th>Onset Date</th>
+              <th>Comments</th>
+              <th>Resolved Date</th>
+            </tr>
+          </thead>
+          <tbody>`;
+        // Process resolved allergies
+        if (resolvedAllergies.length > 0) {
+            html += this.generateAllergyRows(resolvedAllergies, templateUtilities, timezone, true);
+        }
+        else {
+            html += `
+          <tr>
+            <td colspan="8">No resolved allergies recorded</td>
+          </tr>`;
+        }
+        // Close the resolved allergies table
+        html += `
+          </tbody>
+        </table>
+      </div>
+    </div>`;
+        return html;
+    }
+    /**
+     * Helper method to generate HTML table rows for allergies
+     * @param allergies - Array of allergy resources to process
+     * @param templateUtilities - Utilities for formatting
+     * @param includeResolved - Whether to include resolved date column
+     * @param timezone - Optional timezone to use for date formatting
+     * @returns HTML string with table rows
+     */
+    static generateAllergyRows(allergies, templateUtilities, timezone, includeResolved = false) {
+        let html = '';
+        for (const allergy of allergies) {
+            // Find the narrative link extension if it exists
+            // Add a table row for this allergy with appropriate classes
+            html += `
+        <tr id="${(templateUtilities.narrativeLinkId(allergy.extension))}">
+          <td class="Name"><span class="AllergenName">${templateUtilities.codeableConcept(allergy.code)}</span></td>
+          <td class="Status">${templateUtilities.codeableConcept(allergy.clinicalStatus) || '-'}</td>
+          <td class="Category">${templateUtilities.safeConcat(allergy.category, 'value') || '-'}</td>
+          <td class="Reaction">${templateUtilities.concatReactionManifestation(allergy.reaction) || '-'}</td>
+          <td class="Severity">${templateUtilities.safeConcat(allergy.reaction, 'severity') || '-'}</td>
+          <td class="OnsetDate">${templateUtilities.renderTime(allergy.onsetDateTime, timezone) || '-'}</td>
+          <td class="Comments">${templateUtilities.renderNotes(allergy.note, timezone, { styled: true, warning: true })}</td>`;
+            // Add resolved date column for resolved allergies
+            if (includeResolved) {
+                // Try to find end date from extension or use '-' if not found
+                let endDate = '-';
+                if (allergy.extension && Array.isArray(allergy.extension)) {
+                    const endDateExt = allergy.extension.find(ext => ext.url === 'http://hl7.org/fhir/StructureDefinition/allergyintolerance-resolutionDate');
+                    if (endDateExt && endDateExt.valueDateTime) {
+                        endDate = templateUtilities.renderDate(endDateExt.valueDateTime);
+                    }
+                }
+                html += `
+          <td class="ResolvedDate">${endDate}</td>`;
+            }
+            html += `</tr>`;
+        }
+        return html;
+    }
+}