@atomic-ehr/codegen 0.0.1-canary.20250808232913.e62fbdc → 0.0.1-canary.20250810124254.c6a6c21

package/dist/{index-k2baxg01.js → index-t2hbzagh.js}

@@ -1733,10 +1733,16 @@ async function transformProfile(fhirSchema, manager, packageInfo) {
   if (fhirSchema.description) {
     profileSchema.description = fhirSchema.description;
   }
-  const metadata = extractProfileMetadata(fhirSchema);
+  const metadata = extractProfileMetadata(fhirSchema, packageInfo);
   if (Object.keys(metadata).length > 0) {
     profileSchema.metadata = metadata;
   }
+  if (fhirSchema.elements) {
+    const fields = await transformElements(fhirSchema, [], fhirSchema.elements, manager, packageInfo);
+    if (Object.keys(fields).length > 0) {
+      profileSchema.fields = fields;
+    }
+  }
   const constraints = await processProfileConstraints(fhirSchema, manager);
   if (Object.keys(constraints).length > 0) {
     profileSchema.constraints = constraints;
@@ -1766,15 +1772,12 @@ async function determineBaseKind(baseUrl, manager) {
   } catch (error) {
     console.warn(`Could not resolve base schema ${baseUrl}:`, error);
   }
-  if (baseUrl.includes("/us/core/") || baseUrl.includes("StructureDefinition/us-core-")) {
-    return "profile";
-  }
   if (baseUrl.includes("StructureDefinition/") && !baseUrl.startsWith("http://hl7.org/fhir/StructureDefinition/")) {
     return "profile";
   }
   return "resource";
 }
-function extractProfileMetadata(fhirSchema) {
+function extractProfileMetadata(fhirSchema, packageInfo) {
   const metadata = {};
   if (fhirSchema.publisher)
     metadata.publisher = fhirSchema.publisher;
@@ -1791,12 +1794,10 @@ function extractProfileMetadata(fhirSchema) {
     metadata.date = fhirSchema.date;
   if (fhirSchema.jurisdiction)
     metadata.jurisdiction = fhirSchema.jurisdiction;
-  if (fhirSchema.url) {
-    if (fhirSchema.url.includes("/us/core/")) {
-      metadata.package = "hl7.fhir.us.core";
-    } else if (fhirSchema.url.includes("hl7.org/fhir/")) {
-      metadata.package = "hl7.fhir.r4.core";
-    }
+  if (packageInfo?.name) {
+    metadata.package = packageInfo.name;
+  } else if (fhirSchema.package_name) {
+    metadata.package = fhirSchema.package_name;
   }
   return metadata;
 }
@@ -1809,7 +1810,7 @@ async function processProfileConstraints(fhirSchema, _manager) {
     if (element.min !== undefined)
       elementConstraints.min = element.min;
     if (element.max !== undefined)
-      elementConstraints.max = element.max;
+      elementConstraints.max = String(element.max);
     if (element.mustSupport)
       elementConstraints.mustSupport = true;
     if (element.fixedValue !== undefined)
@@ -1819,7 +1820,7 @@ async function processProfileConstraints(fhirSchema, _manager) {
     if (element.binding) {
       elementConstraints.binding = {
         strength: element.binding.strength,
-        valueSet: element.binding.valueSet
+        valueSet: element.binding.valueSet ?? ""
       };
     }
     if (element.type && Array.isArray(element.type) && element.type.length > 0) {
@@ -1834,8 +1835,8 @@ async function processProfileConstraints(fhirSchema, _manager) {
     }
     if (element.slicing) {
       elementConstraints.slicing = {
-        discriminator: element.slicing.discriminator,
-        rules: element.slicing.rules,
+        discriminator: element.slicing.discriminator ?? [],
+        rules: String(element.slicing),
         ordered: element.slicing.ordered
       };
     }
@@ -1857,7 +1858,7 @@ async function processProfileExtensions(fhirSchema, _manager) {
             path: path9,
             profile: type.profile,
             min: element.min,
-            max: element.max,
+            max: String(element.max),
             mustSupport: element.mustSupport
           });
         }
@@ -2951,203 +2952,2340 @@ var isRegularField = (field) => {
 var isTypeSchemaForResourceComplexTypeLogical = (schema) => {
   return schema.identifier.kind === "resource" || schema.identifier.kind === "complex-type" || schema.identifier.kind === "logical";
 };
-// src/api/generators/typescript.ts
+// src/api/generators/rest-client.ts
 import { mkdir as mkdir2, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname, join as join10 } from "node:path";
 
-// src/utils.ts
-function toPascalCase(input) {
-  const parts = input.replace(/[^A-Za-z0-9]+/g, " ").split(" ").map((p) => p.trim()).filter(Boolean);
-  if (parts.length === 0)
-    return "";
-  return parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
-}
-
-// src/api/generators/typescript.ts
-var PRIMITIVE_TYPE_MAP = {
-  string: "string",
-  code: "string",
-  uri: "string",
-  url: "string",
-  canonical: "string",
-  oid: "string",
-  uuid: "string",
-  id: "string",
-  markdown: "string",
-  xhtml: "string",
-  base64Binary: "string",
-  integer: "number",
-  unsignedInt: "number",
-  positiveInt: "number",
-  decimal: "number",
-  boolean: "boolean",
-  date: "string",
-  dateTime: "string",
-  instant: "string",
-  time: "string"
-};
-
-class TypeScriptAPIGenerator {
-  options;
-  imports = new Map;
-  exports = new Set;
+// src/api/generators/search-parameter-enhancer.ts
+class SearchParameterEnhancer {
   resourceTypes = new Set;
-  currentSchemaName;
+  resourceSearchParams = new Map;
+  autocompleteEnabled;
+  valueSetEnumsEnabled;
+  availableEnumTypes = new Map;
+  static BASE_PARAM_NAMES = [
+    "_count",
+    "_offset",
+    "_sort",
+    "_summary",
+    "_elements",
+    "_lastUpdated",
+    "_profile",
+    "_security",
+    "_tag",
+    "_id",
+    "_text",
+    "_content"
+  ];
   constructor(options) {
-    this.options = {
-      moduleFormat: "esm",
-      generateIndex: true,
-      includeDocuments: true,
-      namingConvention: "PascalCase",
-      includeExtensions: false,
-      includeProfiles: false,
-      ...options
-    };
-  }
-  async transformSchema(schema) {
-    this.currentSchemaName = this.formatTypeName(schema.identifier.name);
-    if (schema.identifier.kind === "value-set" || schema.identifier.kind === "binding" || schema.identifier.kind === "primitive-type" || schema.identifier.kind === "profile") {
-      return;
+    this.autocompleteEnabled = !!options?.autocomplete;
+    this.valueSetEnumsEnabled = !!options?.valueSetEnums;
+    console.log(`[DEBUG] SearchParameterEnhancer initialized: autocomplete=${this.autocompleteEnabled}, valueSetEnums=${this.valueSetEnumsEnabled}`);
+  }
+  generateSearchParamNameUnions() {
+    const baseUnion = SearchParameterEnhancer.BASE_PARAM_NAMES.map((n) => `'${n}'`).join(" | ");
+    const parts = [];
+    parts.push(`/**
+ * Base search parameter names available for all resources
+ */`);
+    parts.push(`export type BaseSearchParamName = ${baseUnion};`);
+    parts.push("");
+    const resourceTypesArray = Array.from(this.resourceTypes).sort();
+    for (const [resourceType, params] of this.resourceSearchParams.entries()) {
+      const specificNames = Array.from(new Set(params.map((p) => p.name))).sort();
+      const specificUnion = specificNames.map((n) => `'${n}'`).join(" | ");
+      const typeName = `${resourceType}SearchParamName`;
+      if (specificUnion.length > 0) {
+        parts.push(`/**
+ * Search parameter names for ${resourceType}
+ */`);
+        parts.push(`export type ${typeName} = BaseSearchParamName | ${specificUnion};`);
+      } else {
+        parts.push(`export type ${typeName} = BaseSearchParamName;`);
+      }
+      parts.push("");
     }
-    this.imports.clear();
-    this.exports.clear();
-    this.currentSchemaName = this.formatTypeName(schema.identifier.name);
-    const content = this.generateTypeScriptForSchema(schema);
-    const imports = new Map(this.imports);
-    const filename = this.getFilename(schema.identifier);
-    const exports = Array.from(this.exports.keys());
-    return {
-      content,
-      imports,
-      exports,
-      filename
-    };
+    const mappingLines = resourceTypesArray.map((t) => `	T extends '${t}' ? ${t}SearchParamName :`).join(`
+`);
+    parts.push(`/**
+ * Generic search parameter name union for a given resource type
+ */`);
+    parts.push(`export type SearchParamName<T extends ResourceTypes> =
+${mappingLines}
+	BaseSearchParamName;`);
+    return parts.join(`
+`);
   }
-  generateTypeScriptForSchema(schema) {
-    const lines = [];
-    const interfaceName = this.formatTypeName(schema.identifier.name);
-    let overridedName;
-    if (interfaceName === "Reference") {
-      overridedName = `Reference<T extends ResourceTypes = ResourceTypes>`;
-    }
-    this.exports.add(interfaceName);
-    const baseInterface = this.getBaseInterface(schema);
-    if (baseInterface && !baseInterface.isPrimitive) {
-      this.imports.set(baseInterface.value, baseInterface.value);
-      lines.push(`export interface ${overridedName ?? interfaceName} extends ${baseInterface.value} {`);
-    } else {
-      lines.push(`export interface ${overridedName ?? interfaceName} {`);
+  collectResourceData(schemas) {
+    this.resourceTypes.clear();
+    this.resourceSearchParams.clear();
+    for (const schema of schemas) {
+      if (schema.identifier.kind === "resource" && schema.identifier.name !== "DomainResource" && schema.identifier.name !== "Resource") {
+        this.resourceTypes.add(schema.identifier.name);
+        this.collectSearchParameters(schema);
+      }
     }
-    if (schema.identifier.kind === "resource" && interfaceName !== "DomainResource" && interfaceName !== "Resource") {
-      this.resourceTypes.add(interfaceName);
-      lines.push(`	resourceType: '${interfaceName}';`);
+  }
+  collectSearchParameters(schema) {
+    const resourceType = schema.identifier.name;
+    const searchParams = [];
+    this.addCommonSearchParameters(resourceType, searchParams);
+    this.resourceSearchParams.set(resourceType, searchParams);
+  }
+  addCommonSearchParameters(resourceType, searchParams) {
+    switch (resourceType) {
+      case "Patient":
+        searchParams.push({
+          name: "active",
+          type: "token",
+          description: "Whether the patient record is active"
+        }, {
+          name: "address",
+          type: "string",
+          description: "A server defined search that may match any of the string fields in the Address"
+        }, {
+          name: "address-city",
+          type: "string",
+          description: "A city specified in an address"
+        }, {
+          name: "address-country",
+          type: "string",
+          description: "A country specified in an address"
+        }, {
+          name: "address-postalcode",
+          type: "string",
+          description: "A postalCode specified in an address"
+        }, {
+          name: "address-state",
+          type: "string",
+          description: "A state specified in an address"
+        }, {
+          name: "address-use",
+          type: "token",
+          description: "A use code specified in an address"
+        }, {
+          name: "birthdate",
+          type: "date",
+          description: "The patient's date of birth"
+        }, {
+          name: "death-date",
+          type: "date",
+          description: "The date of death has been provided and satisfies this search value"
+        }, {
+          name: "deceased",
+          type: "token",
+          description: "This patient has been marked as deceased, or as a death date entered"
+        }, {
+          name: "email",
+          type: "token",
+          description: "A value in an email contact"
+        }, {
+          name: "family",
+          type: "string",
+          description: "A portion of the family name of the patient"
+        }, {
+          name: "gender",
+          type: "token",
+          description: "Gender of the patient"
+        }, {
+          name: "general-practitioner",
+          type: "reference",
+          target: ["Organization", "Practitioner", "PractitionerRole"],
+          description: "Patient's nominated general practitioner"
+        }, {
+          name: "given",
+          type: "string",
+          description: "A portion of the given name of the patient"
+        }, {
+          name: "identifier",
+          type: "token",
+          description: "A patient identifier"
+        }, {
+          name: "language",
+          type: "token",
+          description: "Language code (irrespective of use value)"
+        }, {
+          name: "link",
+          type: "reference",
+          target: ["Patient", "RelatedPerson"],
+          description: "All patients linked to the given patient"
+        }, {
+          name: "name",
+          type: "string",
+          description: "A server defined search that may match any of the string fields in the HumanName"
+        }, {
+          name: "organization",
+          type: "reference",
+          target: ["Organization"],
+          description: "The organization that is the custodian of the patient record"
+        }, {
+          name: "phone",
+          type: "token",
+          description: "A value in a phone contact"
+        }, {
+          name: "phonetic",
+          type: "string",
+          description: "A portion of either family or given name using some kind of phonetic matching algorithm"
+        }, {
+          name: "telecom",
+          type: "token",
+          description: "The value in any kind of telecom details of the patient"
+        });
+        break;
+      case "Observation":
+        searchParams.push({
+          name: "category",
+          type: "token",
+          description: "The classification of the type of observation"
+        }, {
+          name: "code",
+          type: "token",
+          description: "The code of the observation type"
+        }, {
+          name: "component-code",
+          type: "token",
+          description: "The component code of the observation type"
+        }, {
+          name: "component-data-absent-reason",
+          type: "token",
+          description: "The reason why the expected value in the element Observation.component.value[x] is missing"
+        }, {
+          name: "component-value-concept",
+          type: "token",
+          description: "The value of the component observation, if the value is a CodeableConcept"
+        }, {
+          name: "component-value-quantity",
+          type: "quantity",
+          description: "The value of the component observation, if the value is a Quantity, or a SampledData"
+        }, {
+          name: "data-absent-reason",
+          type: "token",
+          description: "The reason why the expected value in the element Observation.value[x] is missing"
+        }, {
+          name: "date",
+          type: "date",
+          description: "Obtained date/time. If the obtained element is a period, a date that falls in the period"
+        }, {
+          name: "derived-from",
+          type: "reference",
+          target: [
+            "DocumentReference",
+            "ImagingStudy",
+            "Media",
+            "QuestionnaireResponse",
+            "Observation",
+            "MolecularSequence"
+          ],
+          description: "Related measurements the observation is made from"
+        }, {
+          name: "device",
+          type: "reference",
+          target: ["Device", "DeviceMetric"],
+          description: "The Device that generated the observation data"
+        }, {
+          name: "encounter",
+          type: "reference",
+          target: ["Encounter"],
+          description: "Encounter related to the observation"
+        }, {
+          name: "focus",
+          type: "reference",
+          target: ["Resource"],
+          description: "The focus of an observation when the focus is not the patient of record"
+        }, {
+          name: "has-member",
+          type: "reference",
+          target: [
+            "Observation",
+            "QuestionnaireResponse",
+            "MolecularSequence"
+          ],
+          description: "Related resource that belongs to the Observation group"
+        }, {
+          name: "identifier",
+          type: "token",
+          description: "The unique id for a particular observation"
+        }, {
+          name: "method",
+          type: "token",
+          description: "The method used for the observation"
+        }, {
+          name: "part-of",
+          type: "reference",
+          target: [
+            "MedicationAdministration",
+            "MedicationDispense",
+            "MedicationStatement",
+            "Procedure",
+            "Immunization",
+            "ImagingStudy"
+          ],
+          description: "Part of referenced event"
+        }, {
+          name: "patient",
+          type: "reference",
+          target: ["Patient"],
+          description: "The subject that the observation is about (if patient)"
+        }, {
+          name: "performer",
+          type: "reference",
+          target: [
+            "Practitioner",
+            "PractitionerRole",
+            "Organization",
+            "CareTeam",
+            "Patient",
+            "RelatedPerson"
+          ],
+          description: "Who performed the observation"
+        }, {
+          name: "specimen",
+          type: "reference",
+          target: ["Specimen"],
+          description: "Specimen used for this observation"
+        }, {
+          name: "status",
+          type: "token",
+          description: "The status of the observation"
+        }, {
+          name: "subject",
+          type: "reference",
+          target: ["Patient", "Group", "Device", "Location"],
+          description: "The subject that the observation is about"
+        }, {
+          name: "value-concept",
+          type: "token",
+          description: "The value of the observation, if the value is a CodeableConcept"
+        }, {
+          name: "value-date",
+          type: "date",
+          description: "The value of the observation, if the value is a date or period of time"
+        }, {
+          name: "value-quantity",
+          type: "quantity",
+          description: "The value of the observation, if the value is a Quantity, or a SampledData"
+        }, {
+          name: "value-string",
+          type: "string",
+          description: "The value of the observation, if the value is a string, and also searches in CodeableConcept.text"
+        });
+        break;
+      case "Organization":
+        searchParams.push({
+          name: "active",
+          type: "token",
+          description: "Is the Organization record active"
+        }, {
+          name: "address",
+          type: "string",
+          description: "A server defined search that may match any of the string fields in the Address"
+        }, {
+          name: "address-city",
+          type: "string",
+          description: "A city specified in an address"
+        }, {
+          name: "address-country",
+          type: "string",
+          description: "A country specified in an address"
+        }, {
+          name: "address-postalcode",
+          type: "string",
+          description: "A postal code specified in an address"
+        }, {
+          name: "address-state",
+          type: "string",
+          description: "A state specified in an address"
+        }, {
+          name: "address-use",
+          type: "token",
+          description: "A use code specified in an address"
+        }, {
+          name: "endpoint",
+          type: "reference",
+          target: ["Endpoint"],
+          description: "Technical endpoints providing access to services operated for the organization"
+        }, {
+          name: "identifier",
+          type: "token",
+          description: "Any identifier for the organization (not the accreditation issuer's identifier)"
+        }, {
+          name: "name",
+          type: "string",
+          description: "A portion of the organization's name or alias"
+        }, {
+          name: "partof",
+          type: "reference",
+          target: ["Organization"],
+          description: "An organization of which this organization forms a part"
+        }, {
+          name: "phonetic",
+          type: "string",
+          description: "A portion of the organization's name using some kind of phonetic matching algorithm"
+        }, {
+          name: "type",
+          type: "token",
+          description: "A code for the type of organization"
+        });
+        break;
+      case "Practitioner":
+        searchParams.push({
+          name: "active",
+          type: "token",
+          description: "Whether the practitioner record is active"
+        }, {
+          name: "address",
+          type: "string",
+          description: "A server defined search that may match any of the string fields in the Address"
+        }, {
+          name: "address-city",
+          type: "string",
+          description: "A city specified in an address"
+        }, {
+          name: "address-country",
+          type: "string",
+          description: "A country specified in an address"
+        }, {
+          name: "address-postalcode",
+          type: "string",
+          description: "A postal code specified in an address"
+        }, {
+          name: "address-state",
+          type: "string",
+          description: "A state specified in an address"
+        }, {
+          name: "address-use",
+          type: "token",
+          description: "A use code specified in an address"
+        }, {
+          name: "communication",
+          type: "token",
+          description: "One of the languages that the practitioner can communicate with"
+        }, {
+          name: "email",
+          type: "token",
+          description: "A value in an email contact"
+        }, {
+          name: "family",
+          type: "string",
+          description: "A portion of the family name"
+        }, {
+          name: "gender",
+          type: "token",
+          description: "Gender of the practitioner"
+        }, {
+          name: "given",
+          type: "string",
+          description: "A portion of the given name"
+        }, {
+          name: "identifier",
+          type: "token",
+          description: "A practitioner's Identifier"
+        }, {
+          name: "name",
+          type: "string",
+          description: "A server defined search that may match any of the string fields in the HumanName"
+        }, {
+          name: "phone",
+          type: "token",
+          description: "A value in a phone contact"
+        }, {
+          name: "phonetic",
+          type: "string",
+          description: "A portion of either family or given name using some kind of phonetic matching algorithm"
+        }, {
+          name: "telecom",
+          type: "token",
+          description: "The value in any kind of contact"
+        });
+        break;
+      default:
+        searchParams.push({
+          name: "identifier",
+          type: "token",
+          description: "Resource identifier"
+        });
+        break;
     }
-    if (isTypeSchemaForResourceComplexTypeLogical(schema)) {
-      if (schema.fields) {
-        for (const [fieldName, field] of Object.entries(schema.fields)) {
-          const fieldLine = this.generateField(fieldName, field, {
-            isNested: "type" in field && field.type.kind === "nested",
-            baseName: interfaceName
-          });
-          if (fieldLine) {
-            lines.push(`	${fieldLine}`);
-          }
-        }
-      }
-      lines.push("}");
-      if (schema.nested) {
-        for (const nested of schema.nested) {
-          lines.push("");
-          lines.push(this.generateNested(this.currentSchemaName ?? "", nested));
+  }
+  generateValueSetUnionTypes() {
+    return `/**
+ * Curated ValueSet unions (string literal types)
+ */
+export type PatientGender = 'male' | 'female' | 'other' | 'unknown';
+export type ObservationStatus = 'registered' | 'preliminary' | 'final' | 'amended' | 'corrected' | 'cancelled' | 'entered-in-error' | 'unknown';
+export type ImmunizationStatus = 'completed' | 'entered-in-error' | 'not-done';`;
+  }
+  preprocessEnumTypes() {
+    this.availableEnumTypes.clear();
+    for (const [
+      resourceType,
+      searchParams
+    ] of this.resourceSearchParams.entries()) {
+      for (const param of searchParams) {
+        if (param.type === "token" && this.valueSetEnumsEnabled) {
+          const enumTypeName = `${resourceType}${this.toPascalCase(param.name)}Values`;
+          this.availableEnumTypes.set(`${resourceType}${param.name}`, enumTypeName);
         }
       }
-    } else {
-      lines.push("}");
     }
-    return lines.join(`
+  }
+  toPascalCase(str) {
+    return str.split(/[-_\s]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+  }
+  generateEnhancedSearchTypes() {
+    const resourceTypesArray = Array.from(this.resourceTypes).sort();
+    this.preprocessEnumTypes();
+    const enumImports = this.valueSetEnumsEnabled && this.availableEnumTypes.size > 0 ? `import type { ${Array.from(new Set(this.availableEnumTypes.values())).sort().join(", ")} } from '../types/utility';
+` : "";
+    return `/**
+	* Enhanced Search Parameter Types
+	* 
+	* Type-safe search parameters with modifiers and validation for FHIR resources.
+	* Generated automatically from FHIR schemas.
+	*/
+
+import type { ResourceTypes } from '../types';
+${enumImports}
+
+/**
+* Search parameter modifier types for enhanced type safety
+*/
+export interface SearchModifiers {
+	/** String search modifiers */
+	StringModifier: 
+		| { exact: string }
+		| { contains: string } 
+		| { missing: boolean };
+	
+	/** Date parameter with prefix support */
+	DateParameter: 
+		| string 
+		| { gt: string } 
+		| { lt: string } 
+		| { ge: string } 
+		| { le: string } 
+		| { eq: string }
+		| { ne: string }
+		| { missing: boolean };
+	
+	/** Token parameter for coded values */
+	TokenParameter: 
+		| string 
+		| { system: string; code: string } 
+		| { code: string }
+		| { system: string }
+		| { missing: boolean };
+	
+	/** Token search options (for better autocomplete when enum values exist) */
+	TokenSearchOptions: 
+		| { system: string; code: string } 
+		| { code: string }
+		| { system: string }
+		| { missing: boolean };
+	
+	/** Reference parameter for resource references */
+	ReferenceParameter: 
+		| string 
+		| { reference: string }
+		| { identifier: string }
+		| { missing: boolean };
+	
+	/** Number parameter with range support */
+	NumberParameter: 
+		| number 
+		| { gt: number } 
+		| { lt: number } 
+		| { ge: number } 
+		| { le: number } 
+		| { eq: number }
+		| { ne: number }
+		| { missing: boolean };
+	
+	/** Quantity parameter for measurements */
+	QuantityParameter: 
+		| number 
+		| string
+		| { value: number; unit?: string; system?: string; code?: string }
+		| { missing: boolean };
+}
+
+/**
+ * Base search parameters available for all resources
+ */
+export interface BaseEnhancedSearchParams {
+	/** Number of results to return */
+	_count?: number;
+	/** Pagination offset */
+	_offset?: number;
+	/** Sort order */
+	_sort?: string | string[];
+	/** Summary mode */
+	_summary?: 'true' | 'false' | 'text' | 'data' | 'count';
+	/** Elements to include */
+	_elements?: string | string[];
+	/** Filter by last updated */
+	_lastUpdated?: SearchModifiers['DateParameter'];
+	/** Profile filter */
+	_profile?: string | string[];
+	/** Security label filter */
+	_security?: string | string[];
+	/** Tag filter */
+	_tag?: SearchModifiers['TokenParameter'] | SearchModifiers['TokenParameter'][];
+	/** Filter by ID */
+	_id?: string | string[];
+	/** Text search */
+	_text?: string;
+	/** Content search */
+	_content?: string;
+}
+
+/**
+ * Enhanced search parameters union type for all resources
+ */
+export type EnhancedSearchParams<T extends ResourceTypes> = 
+${resourceTypesArray.map((type) => `	T extends '${type}' ? ${type}SearchParams :`).join(`
+`)}
+	BaseEnhancedSearchParams;
+
+${this.generateResourceSpecificSearchInterfaces()}
+
+${this.autocompleteEnabled ? this.generateSearchParamNameUnions() : ""}
+
+/**
+ * Type-safe search parameter validation helpers
+ */
+export class SearchParameterValidator {
+	/**
+	 * Validate search parameters for a specific resource type
+	 */
+	static validate<T extends ResourceTypes>(
+		resourceType: T, 
+		params: EnhancedSearchParams<T>
+	): { valid: boolean; errors: string[] } {
+		const errors: string[] = [];
+		
+		// Basic validation logic
+		if (params._count !== undefined && (params._count < 0 || params._count > 1000)) {
+			errors.push('_count must be between 0 and 1000');
+		}
+		
+		if (params._offset !== undefined && params._offset < 0) {
+			errors.push('_offset must be non-negative');
+		}
+
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+
+	/**
+	 * Build URL search parameters from enhanced search params
+	 */
+	static buildSearchParams<T extends ResourceTypes>(
+		resourceType: T,
+		params: EnhancedSearchParams<T>
+	): URLSearchParams {
+		const searchParams = new URLSearchParams();
+
+		for (const [key, value] of Object.entries(params)) {
+			if (value === undefined || value === null) continue;
+
+			if (Array.isArray(value)) {
+				value.forEach(v => searchParams.append(key, String(v)));
+			} else if (typeof value === 'object') {
+				// Handle complex parameter objects
+				if ('exact' in value) {
+					searchParams.append(key + ':exact', String(value.exact));
+				} else if ('contains' in value) {
+					searchParams.append(key + ':contains', String(value.contains));
+				} else if ('missing' in value) {
+					searchParams.append(key + ':missing', String(value.missing));
+				} else if ('gt' in value) {
+					searchParams.append(key + ':gt', String(value.gt));
+				} else if ('lt' in value) {
+					searchParams.append(key + ':lt', String(value.lt));
+				} else if ('ge' in value) {
+					searchParams.append(key + ':ge', String(value.ge));
+				} else if ('le' in value) {
+					searchParams.append(key + ':le', String(value.le));
+				} else if ('eq' in value) {
+					searchParams.append(key + ':eq', String(value.eq));
+				} else if ('ne' in value) {
+					searchParams.append(key + ':ne', String(value.ne));
+				} else if ('system' in value && 'code' in value) {
+					searchParams.append(key, \`\${value.system}|\${value.code}\`);
+				} else if ('system' in value) {
+					searchParams.append(key, \`\${value.system}|\`);
+				} else if ('code' in value) {
+					searchParams.append(key, \`|\${value.code}\`);
+				} else if ('reference' in value) {
+					searchParams.append(key, String(value.reference));
+				} else if ('identifier' in value) {
+					searchParams.append(key + ':identifier', String(value.identifier));
+				}
+			} else {
+				searchParams.append(key, String(value));
+			}
+		}
+
+		return searchParams;
+	}
+}`;
+  }
+  generateResourceSpecificSearchInterfaces() {
+    const interfaces = [];
+    for (const [
+      resourceType,
+      searchParams
+    ] of this.resourceSearchParams.entries()) {
+      interfaces.push(this.generateResourceSearchInterface(resourceType, searchParams));
+    }
+    return interfaces.join(`
+
 `);
   }
-  generateNested(baseName, nested) {
-    const lines = [];
-    const interfaceName = this.formatTypeName(nested.identifier.name);
-    this.exports.add(interfaceName);
-    if (nested.base) {
-      const baseInterface = this.getType(nested.base);
-      if (baseInterface.isPrimitive) {
-        lines.push(`export interface ${baseName}${interfaceName}{`);
-      } else {
-        this.imports.set(baseInterface.value, baseInterface.value);
-        lines.push(`export interface ${baseName}${interfaceName} extends ${baseInterface.value} {`);
+  generateResourceSearchInterface(resourceType, searchParams) {
+    const interfaceFields = [];
+    interfaceFields.push("\t// Base search parameters");
+    interfaceFields.push("\t_count?: number;");
+    interfaceFields.push("\t_offset?: number;");
+    interfaceFields.push("\t_sort?: string | string[];");
+    interfaceFields.push("\t_summary?: 'true' | 'false' | 'text' | 'data' | 'count';");
+    interfaceFields.push("\t_elements?: string | string[];");
+    interfaceFields.push("\t_lastUpdated?: SearchModifiers['DateParameter'];");
+    interfaceFields.push("\t_profile?: string | string[];");
+    interfaceFields.push("\t_security?: string | string[];");
+    interfaceFields.push("\t_tag?: SearchModifiers['TokenParameter'] | SearchModifiers['TokenParameter'][];");
+    interfaceFields.push("\t_id?: string | string[];");
+    interfaceFields.push("\t_text?: string;");
+    interfaceFields.push("\t_content?: string;");
+    interfaceFields.push("");
+    if (searchParams.length > 0) {
+      interfaceFields.push(`	// ${resourceType}-specific search parameters`);
+      for (const param of searchParams) {
+        const typeMapping = this.getTypeScriptTypeForSearchParameter(resourceType, param);
+        const comment = param.description ? ` /** ${param.description} */` : "";
+        interfaceFields.push(`${comment}`);
+        interfaceFields.push(`	'${param.name}'?: ${typeMapping};`);
       }
-    } else {
-      lines.push(`export interface ${baseName}${interfaceName}{`);
     }
-    if (nested.fields) {
-      for (const [fieldName, field] of Object.entries(nested.fields)) {
-        const fieldLine = this.generateField(fieldName, field);
-        if (fieldLine) {
-          lines.push(`	${fieldLine}`);
+    return `/**
+ * Enhanced search parameters for ${resourceType} resources
+ */
+export interface ${resourceType}SearchParams extends BaseEnhancedSearchParams {
+${interfaceFields.join(`
+`)}
+}`;
+  }
+  getTypeScriptTypeForSearchParameter(resourceType, param) {
+    switch (param.type) {
+      case "string":
+        return "string | SearchModifiers['StringModifier']";
+      case "number":
+        return "number | SearchModifiers['NumberParameter']";
+      case "date":
+        return "string | SearchModifiers['DateParameter']";
+      case "token":
+        if (this.valueSetEnumsEnabled) {
+          const enumTypeName = this.availableEnumTypes.get(`${resourceType}${param.name}`);
+          if (enumTypeName) {
+            return `${enumTypeName} | SearchModifiers['TokenSearchOptions']`;
+          }
         }
-      }
+        return "string | SearchModifiers['TokenParameter']";
+      case "reference":
+        if (param.target && param.target.length > 0) {
+          return `string | SearchModifiers['ReferenceParameter']`;
+        }
+        return "string | SearchModifiers['ReferenceParameter']";
+      case "quantity":
+        return "number | string | SearchModifiers['QuantityParameter']";
+      case "uri":
+        return "string";
+      case "composite":
+        return "string";
+      default:
+        return "string";
     }
-    lines.push("}");
-    return lines.join(`
-`);
   }
-  generateField(fieldName, field, nestedOpts) {
-    if (isPolymorphicInstanceField(field)) {
-      return this.generatePolymorphicInstance(fieldName, field, nestedOpts);
-    } else if (isRegularField(field)) {
-      return this.generateRegularField(fieldName, field, nestedOpts);
-    }
-    return "";
+  getResourceTypes() {
+    return this.resourceTypes;
   }
-  generatePolymorphicInstance(fieldName, field, nestedOpts) {
-    let typeString = "any";
-    if (field.reference) {
-      typeString = this.buildReferenceType(field.reference);
-    } else if (field.type) {
-      const subType = this.getType(field.type);
-      if (!subType.isPrimitive && !nestedOpts?.isNested) {
-        this.imports.set(subType.value, subType.value);
+}
+
+// src/api/generators/validation-generator.ts
+class ValidationGenerator {
+  resourceTypes = new Set;
+  resourceSchemas = new Map;
+  collectResourceData(schemas) {
+    this.resourceTypes.clear();
+    this.resourceSchemas.clear();
+    for (const schema of schemas) {
+      if (schema.identifier.kind === "resource" && schema.identifier.name !== "DomainResource" && schema.identifier.name !== "Resource") {
+        this.resourceTypes.add(schema.identifier.name);
+        this.resourceSchemas.set(schema.identifier.name, schema);
       }
-      typeString = subType.value;
     }
-    const optional = !field.required ? "?" : "";
-    const array = field.array ? "[]" : "";
-    return `${fieldName}${optional}: ${nestedOpts?.isNested && nestedOpts.baseName ? nestedOpts.baseName : ""}${typeString}${array};`;
   }
-  generateRegularField(fieldName, field, nestedOpts) {
-    let typeString = "any";
-    if (field.enum) {
-      if (field.enum.length > 15) {
-        typeString = "string";
-      } else {
-        typeString = `${field.enum.map((e) => `'${e}'`).join(" | ")}`;
+  generateValidationTypes() {
+    return `/**
+ * FHIR Resource Validation Types
+ * 
+ * Client-side validation types and interfaces for FHIR resources.
+ * Generated automatically from FHIR schemas.
+ */
+
+import type { ResourceTypes } from '../types';
+
+/**
+ * Validation options for resource validation
+ */
+export interface ValidationOptions {
+	/** Validation profile to use (strict, lenient, etc.) */
+	profile?: 'strict' | 'lenient' | 'minimal';
+	/** Whether to throw on validation errors or return result */
+	throwOnError?: boolean;
+	/** Whether to validate required fields */
+	validateRequired?: boolean;
+	/** Whether to validate cardinality constraints */
+	validateCardinality?: boolean;
+	/** Whether to validate data types */
+	validateTypes?: boolean;
+	/** Whether to validate value constraints */
+	validateConstraints?: boolean;
+	/** Whether to collect performance metrics */
+	collectMetrics?: boolean;
+}
+
+/**
+ * Validation error details
+ */
+export interface ValidationError {
+	/** Error severity */
+	severity: 'error' | 'warning' | 'information';
+	/** Error code */
+	code: string;
+	/** Human-readable error message */
+	message: string;
+	/** Path to the invalid element */
+	path: string;
+	/** Current value that failed validation */
+	value?: unknown;
+	/** Expected value or constraint */
+	expected?: string;
+	/** Suggestion for fixing the error */
+	suggestion?: string;
+}
+
+/**
+ * Validation warning details
+ */
+export interface ValidationWarning {
+	/** Warning code */
+	code: string;
+	/** Human-readable warning message */
+	message: string;
+	/** Path to the element */
+	path: string;
+	/** Current value */
+	value?: unknown;
+	/** Suggestion for improvement */
+	suggestion?: string;
+}
+
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+	/** Whether validation passed */
+	valid: boolean;
+	/** List of validation errors */
+	errors: ValidationError[];
+	/** List of validation warnings */
+	warnings: ValidationWarning[];
+	/** Validation performance metrics */
+	metrics?: {
+		/** Time taken for validation in milliseconds */
+		duration: number;
+		/** Number of elements validated */
+		elementsValidated: number;
+		/** Number of constraints checked */
+		constraintsChecked: number;
+	};
+}
+
+/**
+ * Validation exception thrown when validation fails and throwOnError is true
+ */
+export class ValidationException extends Error {
+	public errors: ValidationError[];
+	public warnings: ValidationWarning[];
+	public result: ValidationResult;
+
+	constructor(result: ValidationResult) {
+		const errorCount = result.errors.length;
+		const warningCount = result.warnings.length;
+		super(\`Validation failed: \${errorCount} error(s), \${warningCount} warning(s)\`);
+		
+		this.name = 'ValidationException';
+		this.errors = result.errors;
+		this.warnings = result.warnings;
+		this.result = result;
+	}
+}`;
+  }
+  generateResourceValidators() {
+    const resourceTypesArray = Array.from(this.resourceTypes).sort();
+    return `/**
+ * FHIR Resource Validators
+ * 
+ * Client-side validation logic for FHIR resources.
+ * Generated automatically from FHIR schemas.
+ */
+
+import type { ResourceTypes, ResourceTypeMap, ${resourceTypesArray.join(", ")} } from './utility';
+import type { ValidationOptions, ValidationResult, ValidationError, ValidationWarning, ValidationException } from './validation-types';
+
+/**
+ * Main Resource Validator class
+ * 
+ * Provides validation methods for all FHIR resource types with configurable
+ * validation profiles and detailed error reporting.
+ */
+export class ResourceValidator {
+	private static defaultOptions: Required<ValidationOptions> = {
+		profile: 'strict',
+		throwOnError: false,
+		validateRequired: true,
+		validateCardinality: true,
+		validateTypes: true,
+		validateConstraints: true,
+		collectMetrics: false
+	};
+
+	/**
+	 * Validate any FHIR resource with type safety
+	 */
+	static validate<T extends ResourceTypes>(
+		resource: ResourceTypeMap[T],
+		options: ValidationOptions = {}
+	): ValidationResult {
+		const opts = { ...this.defaultOptions, ...options };
+		const startTime = opts.collectMetrics ? performance.now() : 0;
+
+		const result: ValidationResult = {
+			valid: true,
+			errors: [],
+			warnings: []
+		};
+
+		try {
+			// Basic resource type validation
+			if (!resource || typeof resource !== 'object') {
+				result.errors.push({
+					severity: 'error',
+					code: 'INVALID_RESOURCE',
+					message: 'Resource must be a valid object',
+					path: 'resource',
+					value: resource,
+					expected: 'object',
+					suggestion: 'Provide a valid FHIR resource object'
+				});
+				result.valid = false;
+			} else {
+				// Validate resource type
+				const resourceType = resource.resourceType as T;
+				if (!resourceType) {
+					result.errors.push({
+						severity: 'error',
+						code: 'MISSING_RESOURCE_TYPE',
+						message: 'Resource must have a resourceType property',
+						path: 'resourceType',
+						value: undefined,
+						expected: 'string',
+						suggestion: 'Add a resourceType property to the resource'
+					});
+					result.valid = false;
+				} else {
+					// Call resource-specific validator
+					this.validateResourceType(resourceType, resource, result, opts);
+				}
+			}
+
+			// Add performance metrics if requested
+			if (opts.collectMetrics) {
+				const endTime = performance.now();
+				result.metrics = {
+					duration: endTime - startTime,
+					elementsValidated: this.countElements(resource),
+					constraintsChecked: result.errors.length + result.warnings.length
+				};
+			}
+
+			// Throw exception if requested and validation failed
+			if (opts.throwOnError && !result.valid) {
+				const { ValidationException } = require('./validation-types');
+				throw new ValidationException(result);
+			}
+
+			return result;
+
+		} catch (error) {
+			if (error instanceof Error && error.name === 'ValidationException') {
+				throw error;
+			}
+
+			result.errors.push({
+				severity: 'error',
+				code: 'VALIDATION_ERROR',
+				message: \`Validation failed: \${error instanceof Error ? error.message : String(error)}\`,
+				path: 'resource',
+				value: resource,
+				suggestion: 'Check the resource structure and try again'
+			});
+			result.valid = false;
+
+			if (opts.throwOnError) {
+				const { ValidationException } = require('./validation-types');
+				throw new ValidationException(result);
+			}
+
+			return result;
+		}
+	}
+
+${this.generateResourceSpecificValidators()}
+
+	/**
+	 * Validate resource type and dispatch to specific validator
+	 */
+	private static validateResourceType<T extends ResourceTypes>(
+		resourceType: T,
+		resource: ResourceTypeMap[T],
+		result: ValidationResult,
+		options: Required<ValidationOptions>
+	): void {
+		switch (resourceType) {
+${resourceTypesArray.map((type) => `			case '${type}':
+				this.validate${type}(resource as ${type}, result, options);
+				break;`).join(`
+`)}
+			default:
+				result.warnings.push({
+					code: 'UNKNOWN_RESOURCE_TYPE',
+					message: \`Unknown resource type: \${resourceType}\`,
+					path: 'resourceType',
+					value: resourceType,
+					suggestion: 'Check if the resource type is supported'
+				});
+		}
+	}
+
+	/**
+	 * Count elements in resource for metrics
+	 */
+	private static countElements(resource: any, count = 0): number {
+		if (!resource || typeof resource !== 'object') return count;
+		
+		for (const value of Object.values(resource)) {
+			count++;
+			if (Array.isArray(value)) {
+				for (const item of value) {
+					count = this.countElements(item, count);
+				}
+			} else if (typeof value === 'object') {
+				count = this.countElements(value, count);
+			}
+		}
+		
+		return count;
+	}
+
+	/**
+	 * Validate required fields
+	 */
+	private static validateRequired(
+		resource: any,
+		requiredFields: string[],
+		result: ValidationResult,
+		basePath = ''
+	): void {
+		for (const field of requiredFields) {
+			const path = basePath ? \`\${basePath}.\${field}\` : field;
+			if (resource[field] === undefined || resource[field] === null) {
+				result.errors.push({
+					severity: 'error',
+					code: 'MISSING_REQUIRED_FIELD',
+					message: \`Required field '\${field}' is missing\`,
+					path,
+					value: resource[field],
+					expected: 'non-null value',
+					suggestion: \`Add the required '\${field}' field to the resource\`
+				});
+				result.valid = false;
+			}
+		}
+	}
+
+	/**
+	 * Validate field type
+	 */
+	private static validateFieldType(
+		value: any,
+		expectedType: string,
+		fieldName: string,
+		result: ValidationResult,
+		basePath = ''
+	): void {
+		const path = basePath ? \`\${basePath}.\${fieldName}\` : fieldName;
+		
+		if (value === undefined || value === null) return;
+
+		let isValid = false;
+		switch (expectedType) {
+			case 'string':
+				isValid = typeof value === 'string';
+				break;
+			case 'number':
+				isValid = typeof value === 'number' && !isNaN(value);
+				break;
+			case 'boolean':
+				isValid = typeof value === 'boolean';
+				break;
+			case 'array':
+				isValid = Array.isArray(value);
+				break;
+			case 'object':
+				isValid = typeof value === 'object' && !Array.isArray(value);
+				break;
+			default:
+				isValid = true; // Skip unknown types
+		}
+
+		if (!isValid) {
+			result.errors.push({
+				severity: 'error',
+				code: 'INVALID_FIELD_TYPE',
+				message: \`Field '\${fieldName}' has invalid type\`,
+				path,
+				value,
+				expected: expectedType,
+				suggestion: \`Ensure '\${fieldName}' is of type \${expectedType}\`
+			});
+			result.valid = false;
+		}
+	}
+}`;
+  }
+  generateResourceSpecificValidators() {
+    const validators = [];
+    const keyResourceTypes = [
+      "Patient",
+      "Observation",
+      "Organization",
+      "Practitioner",
+      "Bundle"
+    ];
+    for (const resourceType of keyResourceTypes) {
+      if (this.resourceTypes.has(resourceType)) {
+        validators.push(this.generateResourceValidator(resourceType));
       }
-    } else if (field.reference) {
-      typeString = this.buildReferenceType(field.reference);
-    } else if (field.type) {
-      const subType = this.getType(field.type);
-      if (!subType.isPrimitive && !nestedOpts?.isNested) {
-        this.imports.set(subType.value, subType.value);
+    }
+    for (const resourceType of this.resourceTypes) {
+      if (!keyResourceTypes.includes(resourceType)) {
+        validators.push(this.generateGenericResourceValidator(resourceType));
       }
-      typeString = subType.value;
     }
-    if (nestedOpts?.baseName === "Reference" && fieldName === "type") {
-      typeString = "T";
-      this.imports.set("ResourceTypes", "utility");
+    return validators.join(`
+
+`);
+  }
+  generateResourceValidator(resourceType) {
+    const validationRules = this.getValidationRules(resourceType);
+    return `	/**
+	 * Validate ${resourceType} resource
+	 */
+	private static validate${resourceType}(
+		resource: ${resourceType},
+		result: ValidationResult,
+		options: Required<ValidationOptions>
+	): void {
+		// Validate required fields
+		if (options.validateRequired) {
+			this.validateRequired(resource, [${validationRules.required.map((f) => `'${f}'`).join(", ")}], result, '${resourceType.toLowerCase()}');
+		}
+
+		// Validate field types
+		if (options.validateTypes) {
+			${validationRules.fields.map((field) => `if (resource.${field.name} !== undefined) {
+				this.validateFieldType(resource.${field.name}, '${field.type}', '${field.name}', result, '${resourceType.toLowerCase()}');
+			}`).join(`
+			`)}
+		}
+
+		// Validate specific constraints for ${resourceType}
+		if (options.validateConstraints) {
+			${this.generateResourceSpecificConstraints(resourceType)}
+		}
+	}`;
+  }
+  generateGenericResourceValidator(resourceType) {
+    return `	/**
+	 * Validate ${resourceType} resource (generic validation)
+	 */
+	private static validate${resourceType}(
+		resource: ${resourceType},
+		result: ValidationResult,
+		options: Required<ValidationOptions>
+	): void {
+		// Basic validation for ${resourceType}
+		if (options.validateRequired && resource.resourceType !== '${resourceType}') {
+			result.errors.push({
+				severity: 'error',
+				code: 'INVALID_RESOURCE_TYPE',
+				message: \`Expected resourceType '${resourceType}', got '\${resource.resourceType}'\`,
+				path: 'resourceType',
+				value: resource.resourceType,
+				expected: '${resourceType}',
+				suggestion: 'Ensure the resourceType matches the expected value'
+			});
+			result.valid = false;
+		}
+
+		// Generic field validation
+		if (options.validateTypes) {
+			// Validate common fields
+			if (resource.id !== undefined) {
+				this.validateFieldType(resource.id, 'string', 'id', result, '${resourceType.toLowerCase()}');
+			}
+			if ((resource as any).meta !== undefined) {
+				this.validateFieldType((resource as any).meta, 'object', 'meta', result, '${resourceType.toLowerCase()}');
+			}
+		}
+	}`;
+  }
+  getValidationRules(resourceType) {
+    switch (resourceType) {
+      case "Patient":
+        return {
+          required: ["resourceType"],
+          fields: [
+            { name: "id", type: "string" },
+            { name: "meta", type: "object" },
+            { name: "identifier", type: "array" },
+            { name: "active", type: "boolean" },
+            { name: "name", type: "array" },
+            { name: "telecom", type: "array" },
+            { name: "gender", type: "string" },
+            { name: "birthDate", type: "string" },
+            { name: "address", type: "array" }
+          ]
+        };
+      case "Observation":
+        return {
+          required: ["resourceType", "status", "code"],
+          fields: [
+            { name: "id", type: "string" },
+            { name: "meta", type: "object" },
+            { name: "identifier", type: "array" },
+            { name: "status", type: "string" },
+            { name: "category", type: "array" },
+            { name: "code", type: "object" },
+            { name: "subject", type: "object" },
+            { name: "effectiveDateTime", type: "string" },
+            { name: "valueQuantity", type: "object" },
+            { name: "valueString", type: "string" },
+            { name: "valueBoolean", type: "boolean" }
+          ]
+        };
+      case "Organization":
+        return {
+          required: ["resourceType"],
+          fields: [
+            { name: "id", type: "string" },
+            { name: "meta", type: "object" },
+            { name: "identifier", type: "array" },
+            { name: "active", type: "boolean" },
+            { name: "type", type: "array" },
+            { name: "name", type: "string" },
+            { name: "telecom", type: "array" },
+            { name: "address", type: "array" }
+          ]
+        };
+      case "Practitioner":
+        return {
+          required: ["resourceType"],
+          fields: [
+            { name: "id", type: "string" },
+            { name: "meta", type: "object" },
+            { name: "identifier", type: "array" },
+            { name: "active", type: "boolean" },
+            { name: "name", type: "array" },
+            { name: "telecom", type: "array" },
+            { name: "address", type: "array" },
+            { name: "gender", type: "string" },
+            { name: "birthDate", type: "string" }
+          ]
+        };
+      case "Bundle":
+        return {
+          required: ["resourceType", "type"],
+          fields: [
+            { name: "id", type: "string" },
+            { name: "meta", type: "object" },
+            { name: "identifier", type: "object" },
+            { name: "type", type: "string" },
+            { name: "timestamp", type: "string" },
+            { name: "total", type: "number" },
+            { name: "entry", type: "array" }
+          ]
+        };
+      default:
+        return {
+          required: ["resourceType"],
+          fields: [
+            { name: "id", type: "string" },
+            { name: "meta", type: "object" }
+          ]
+        };
     }
-    const optional = !field.required ? "?" : "";
-    const array = field.array ? "[]" : "";
-    return `${fieldName}${optional}: ${nestedOpts?.isNested && nestedOpts.baseName ? nestedOpts.baseName : ""}${typeString}${array};`;
   }
-  buildReferenceType(refers) {
-    this.imports.set("Reference", "Reference");
-    if (refers.length === 0) {
-      return "Reference";
+  generateResourceSpecificConstraints(resourceType) {
+    switch (resourceType) {
+      case "Patient":
+        return `// Patient-specific constraints
+			if (resource.gender && !['male', 'female', 'other', 'unknown'].includes(resource.gender)) {
+				result.errors.push({
+					severity: 'error',
+					code: 'INVALID_GENDER_VALUE',
+					message: 'Invalid gender value',
+					path: 'patient.gender',
+					value: resource.gender,
+					expected: 'male, female, other, or unknown',
+					suggestion: 'Use a valid gender code'
+				});
+				result.valid = false;
+			}`;
+      case "Observation":
+        return `// Observation-specific constraints
+			if (resource.status && !['registered', 'preliminary', 'final', 'amended', 'corrected', 'cancelled', 'entered-in-error', 'unknown'].includes(resource.status)) {
+				result.errors.push({
+					severity: 'error',
+					code: 'INVALID_OBSERVATION_STATUS',
+					message: 'Invalid observation status',
+					path: 'observation.status',
+					value: resource.status,
+					expected: 'valid observation status code',
+					suggestion: 'Use a valid observation status code'
+				});
+				result.valid = false;
+			}`;
+      case "Bundle":
+        return `// Bundle-specific constraints
+			if (resource.type && !['document', 'message', 'transaction', 'transaction-response', 'batch', 'batch-response', 'history', 'searchset', 'collection'].includes(resource.type)) {
+				result.errors.push({
+					severity: 'error',
+					code: 'INVALID_BUNDLE_TYPE',
+					message: 'Invalid bundle type',
+					path: 'bundle.type',
+					value: resource.type,
+					expected: 'valid bundle type code',
+					suggestion: 'Use a valid bundle type code'
+				});
+				result.valid = false;
+			}`;
+      default:
+        return `// Generic resource constraints
+			// No specific constraints for ${resourceType}`;
     }
-    if (refers.length === 1 && refers[0]?.name === "Resource") {
+  }
+  getResourceTypes() {
+    return this.resourceTypes;
+  }
+}
+
+// src/api/generators/rest-client.ts
+class RestClientGenerator {
+  options;
+  resourceTypes = new Set;
+  searchParameterEnhancer;
+  validationGenerator;
+  constructor(options) {
+    this.options = {
+      clientName: "FHIRClient",
+      includeValidation: false,
+      includeErrorHandling: true,
+      includeRequestInterceptors: false,
+      baseUrlOverride: "",
+      enhancedSearch: false,
+      includeUtilities: true,
+      generateValidators: false,
+      useCanonicalManager: true,
+      defaultTimeout: 30000,
+      defaultRetries: 0,
+      includeDocumentation: true,
+      generateExamples: false,
+      chainedSearchBuilder: false,
+      searchAutocomplete: true,
+      generateValueSetEnums: true,
+      ...options
+    };
+    console.log(`[DEBUG] REST client configured with options:`, this.options);
+    this.searchParameterEnhancer = new SearchParameterEnhancer({
+      autocomplete: this.options.searchAutocomplete ?? false,
+      valueSetEnums: this.options.generateValueSetEnums ?? false
+    });
+    this.validationGenerator = new ValidationGenerator;
+  }
+  collectResourceTypes(schemas) {
+    this.resourceTypes.clear();
+    for (const schema of schemas) {
+      if (schema.identifier.kind === "resource" && schema.identifier.name !== "DomainResource" && schema.identifier.name !== "Resource") {
+        this.resourceTypes.add(schema.identifier.name);
+      }
+    }
+    if (this.options.enhancedSearch) {
+      this.searchParameterEnhancer.collectResourceData(schemas);
+    }
+    if (this.options.includeValidation || this.options.generateValidators) {
+      this.validationGenerator.collectResourceData(schemas);
+    }
+  }
+  async generate(schemas) {
+    this.collectResourceTypes(schemas);
+    await mkdir2(this.options.outputDir, { recursive: true });
+    const generatedFiles = [];
+    const clientFile = await this.generateClientFile();
+    const clientPath = join10(this.options.outputDir, clientFile.filename);
+    await this.ensureDirectoryExists(clientPath);
+    await writeFile4(clientPath, clientFile.content, "utf-8");
+    generatedFiles.push({
+      ...clientFile,
+      path: clientPath
+    });
+    const typesFile = await this.generateTypesFile();
+    const typesPath = join10(this.options.outputDir, typesFile.filename);
+    await writeFile4(typesPath, typesFile.content, "utf-8");
+    generatedFiles.push({
+      ...typesFile,
+      path: typesPath
+    });
+    if (this.options.enhancedSearch) {
+      const searchParamsFile = await this.generateEnhancedSearchParamsFile();
+      const searchParamsPath = join10(this.options.outputDir, searchParamsFile.filename);
+      await writeFile4(searchParamsPath, searchParamsFile.content, "utf-8");
+      generatedFiles.push({
+        ...searchParamsFile,
+        path: searchParamsPath
+      });
+    }
+    if (this.options.includeValidation || this.options.generateValidators) {
+      const validationTypesFile = await this.generateValidationTypesFile();
+      const validationTypesPath = join10(this.options.outputDir, validationTypesFile.filename);
+      await writeFile4(validationTypesPath, validationTypesFile.content, "utf-8");
+      generatedFiles.push({
+        ...validationTypesFile,
+        path: validationTypesPath
+      });
+      const validatorsFile = await this.generateValidatorsFile();
+      const validatorsPath = join10(this.options.outputDir, validatorsFile.filename);
+      await writeFile4(validatorsPath, validatorsFile.content, "utf-8");
+      generatedFiles.push({
+        ...validatorsFile,
+        path: validatorsPath
+      });
+    }
+    const utilityFile = await this.generateUtilityFile();
+    const utilityPath = join10(this.options.outputDir, utilityFile.filename);
+    await writeFile4(utilityPath, utilityFile.content, "utf-8");
+    generatedFiles.push({
+      ...utilityFile,
+      path: utilityPath
+    });
+    return generatedFiles;
+  }
+  async generateClientFile() {
+    const resourceTypesArray = Array.from(this.resourceTypes).sort();
+    const clientName = this.options.clientName;
+    const enhancedSearchImports = this.options.enhancedSearch ? `import type { 
+	EnhancedSearchParams,
+	SearchParameterValidator${this.options.searchAutocomplete ? `,
+	SearchParamName,
+	BaseEnhancedSearchParams` : ""} 
+} from './enhanced-search-params';` : "";
+    const validationImports = this.options.includeValidation || this.options.generateValidators ? `import type { 
+	ValidationOptions,
+	ValidationResult,
+	ValidationException 
+} from './validation-types';
+import { ResourceValidator } from './resource-validators';` : "";
+    const searchParamType = "SearchParams,";
+    const content = `/**
+ * FHIR REST Client
+ * 
+ * Type-safe FHIR REST client with autocompletion for all resource types.
+ * Generated automatically from FHIR schemas.
+ */
+
+import type { 
+	ResourceTypes,
+	Bundle,
+	OperationOutcome,
+	${resourceTypesArray.join(`,
+	`)}
+} from '../types';
+import type { 
+	${clientName}Config,
+	${searchParamType}
+	CreateResponse,
+	UpdateResponse,
+	DeleteResponse,
+	ReadResponse,
+	SearchResponse,
+	RequestOptions,
+	HTTPMethod 
+} from './client-types';
+${enhancedSearchImports}
+${validationImports}
+import type { ResourceTypeMap } from './utility';
+
+/**
+ * Main FHIR REST Client
+ * 
+ * Provides type-safe operations for all FHIR resources with autocompletion.
+ */
+export class ${clientName} {
+	private baseUrl: string;
+	private config: Required<${clientName}Config>;
+
+	constructor(baseUrl: string, config: ${clientName}Config = {}) {
+		this.baseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+		this.config = {
+			timeout: 30000,
+			retries: 0,
+			headers: {},
+			validateResponses: false,
+			...config
+		};
+	}
+
+${this.generateCRUDMethods()}
+
+${this.generateSearchMethod()}
+
+	/**
+	 * Get server capability statement
+	 */
+	async getCapabilities(): Promise<any> {
+		const url = \`\${this.baseUrl}/metadata\`;
+		return this.request('GET', url);
+	}
+
+	/**
+	 * Execute raw HTTP request with full control
+	 */
+	async request<T = any>(
+		method: HTTPMethod,
+		url: string,
+		body?: any,
+		options?: RequestOptions
+	): Promise<T> {
+		const requestOptions: RequestInit = {
+			method,
+			headers: {
+				'Content-Type': 'application/fhir+json',
+				'Accept': 'application/fhir+json',
+				...this.config.headers,
+				...options?.headers
+			},
+			signal: options?.signal || (this.config.timeout > 0 
+				? AbortSignal.timeout(this.config.timeout) 
+				: undefined
+			)
+		};
+
+		if (body && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+			requestOptions.body = JSON.stringify(body);
+		}
+
+		${this.options.includeErrorHandling ? this.generateErrorHandling() : "const response = await fetch(url, requestOptions);"}
+
+		if (!response.ok) {
+			await this.handleErrorResponse(response);
+		}
+
+		// Handle different response types
+		const contentType = response.headers.get('content-type');
+		if (contentType?.includes('application/json') || contentType?.includes('application/fhir+json')) {
+			return response.json();
+		} else if (method === 'DELETE') {
+			return undefined as T;
+		} else {
+			return response.text() as T;
+		}
+	}
+
+	${this.options.includeErrorHandling ? this.generateErrorHandlingMethods() : ""}
+
+	/**
+	 * Update client configuration
+	 */
+	updateConfig(config: Partial<${clientName}Config>): void {
+		this.config = { ...this.config, ...config };
+	}
+
+	/**
+	 * Get current configuration
+	 */
+	getConfig(): Required<${clientName}Config> {
+		return { ...this.config };
+	}
+
+	/**
+	 * Get base URL
+	 */
+	getBaseUrl(): string {
+		return this.baseUrl;
+	}${this.generateValidationMethods()}
+}
+
+export default ${clientName};`;
+    return {
+      filename: `${clientName.toLowerCase()}.ts`,
+      content,
+      exports: [clientName]
+    };
+  }
+  async generateTypesFile() {
+    const content = `/**
+ * FHIR REST Client Types
+ * 
+ * Type definitions for the FHIR REST client.
+ */
+
+import type { Bundle } from '../types';
+import type { ResourceTypeMap } from './utility';
+
+/**
+ * HTTP methods supported by the client
+ */
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+
+/**
+ * Client configuration options
+ */
+export interface ${this.options.clientName}Config {
+	/** Request timeout in milliseconds (default: 30000) */
+	timeout?: number;
+	/** Number of retries for failed requests (default: 0) */
+	retries?: number;
+	/** Default headers to include with all requests */
+	headers?: Record<string, string>;
+	/** Whether to validate response schemas (default: false) */
+	validateResponses?: boolean;${this.generateValidationConfigFields()}
+}
+
+/**
+ * Request options for individual operations
+ */
+export interface RequestOptions {
+	/** Additional headers for this request */
+	headers?: Record<string, string>;
+	/** AbortSignal to cancel the request */
+	signal?: AbortSignal;
+}
+
+/**
+ * Generic search parameters
+ */
+export interface SearchParams {
+	/** Number of results to return */
+	_count?: number;
+	/** Pagination offset */
+	_offset?: number;
+	/** Include related resources */
+	_include?: string | string[];
+	/** Reverse include */
+	_revinclude?: string | string[];
+	/** Summary mode */
+	_summary?: 'true' | 'false' | 'text' | 'data' | 'count';
+	/** Elements to include */
+	_elements?: string | string[];
+	/** Any other FHIR search parameters */
+	[key: string]: any;
+}
+
+/**
+ * Response type for create operations
+ */
+export interface CreateResponse<T extends keyof ResourceTypeMap> {
+	/** The created resource */
+	resource: ResourceTypeMap[T];
+	/** Response status code */
+	status: number;
+	/** Response headers */
+	headers: Headers;
+}
+
+/**
+ * Response type for read operations
+ */
+export interface ReadResponse<T extends keyof ResourceTypeMap> {
+	/** The retrieved resource */
+	resource: ResourceTypeMap[T];
+	/** Response status code */
+	status: number;
+	/** Response headers */
+	headers: Headers;
+}
+
+/**
+ * Response type for update operations
+ */
+export interface UpdateResponse<T extends keyof ResourceTypeMap> {
+	/** The updated resource */
+	resource: ResourceTypeMap[T];
+	/** Response status code */
+	status: number;
+	/** Response headers */
+	headers: Headers;
+}
+
+/**
+ * Response type for delete operations
+ */
+export interface DeleteResponse {
+	/** Response status code */
+	status: number;
+	/** Response headers */
+	headers: Headers;
+}
+
+/**
+ * Response type for search operations
+ */
+export interface SearchResponse<T extends keyof ResourceTypeMap> {
+	/** The search result bundle */
+	bundle: Bundle<ResourceTypeMap[T]>;
+	/** Response status code */
+	status: number;
+	/** Response headers */
+	headers: Headers;
+}
+
+/**
+ * FHIR operation outcome for errors
+ */
+export interface FHIRError extends Error {
+	/** FHIR OperationOutcome */
+	operationOutcome?: import('../types').OperationOutcome;
+	/** HTTP status code */
+	status?: number;
+	/** Response headers */
+	headers?: Headers;
+}`;
+    return {
+      filename: "client-types.ts",
+      content,
+      exports: [
+        "HTTPMethod",
+        `${this.options.clientName}Config`,
+        "RequestOptions",
+        "SearchParams",
+        "CreateResponse",
+        "ReadResponse",
+        "UpdateResponse",
+        "DeleteResponse",
+        "SearchResponse",
+        "FHIRError"
+      ]
+    };
+  }
+  generateErrorHandling() {
+    return `let response: Response;
+		let retryCount = 0;
+		
+		while (retryCount <= this.config.retries) {
+			try {
+				response = await fetch(url, requestOptions);
+				break;
+			} catch (error) {
+				if (retryCount === this.config.retries) {
+					throw error;
+				}
+				retryCount++;
+				await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
+			}
+		}`;
+  }
+  generateErrorHandlingMethods() {
+    return `
+	/**
+	 * Handle error responses from the FHIR server
+	 */
+	private async handleErrorResponse(response: Response): Promise<never> {
+		let operationOutcome: any;
+		
+		try {
+			const contentType = response.headers.get('content-type');
+			if (contentType?.includes('application/json') || contentType?.includes('application/fhir+json')) {
+				operationOutcome = await response.json();
+			}
+		} catch {
+			// Ignore JSON parsing errors
+		}
+
+		const error = new Error(\`HTTP \${response.status}: \${response.statusText}\`) as any;
+		error.status = response.status;
+		error.headers = response.headers;
+		error.operationOutcome = operationOutcome;
+
+		throw error;
+	}`;
+  }
+  setOutputDir(directory) {
+    this.options.outputDir = directory;
+  }
+  setOptions(options) {
+    this.options = { ...this.options, ...options };
+  }
+  getOptions() {
+    return { ...this.options };
+  }
+  async generateEnhancedSearchParamsFile() {
+    const content = this.searchParameterEnhancer.generateEnhancedSearchTypes();
+    const baseExports = [
+      "EnhancedSearchParams",
+      "SearchParameterValidator",
+      "SearchModifiers",
+      "BaseEnhancedSearchParams",
+      ...Array.from(this.resourceTypes).sort().map((type) => `${type}SearchParams`)
+    ];
+    const autocompleteExports = this.options.searchAutocomplete ? [
+      "BaseSearchParamName",
+      "SearchParamName",
+      ...Array.from(this.resourceTypes).sort().map((type) => `${type}SearchParamName`)
+    ] : [];
+    const valueSetEnumExports = this.options.generateValueSetEnums ? ["PatientGender", "ObservationStatus", "ImmunizationStatus"] : [];
+    return {
+      filename: "enhanced-search-params.ts",
+      content,
+      exports: [...baseExports, ...autocompleteExports, ...valueSetEnumExports]
+    };
+  }
+  generateValidationConfigFields() {
+    if (this.options.includeValidation || this.options.generateValidators) {
+      return `
+	/** Client-side validation options */
+	validation?: {
+		/** Enable client-side validation (default: false) */
+		enabled?: boolean;
+		/** Validation profile to use (default: 'strict') */
+		profile?: 'strict' | 'lenient' | 'minimal';
+		/** Whether to throw on validation errors (default: false) */
+		throwOnError?: boolean;
+		/** Whether to validate before sending requests (default: true) */
+		validateBeforeRequest?: boolean;
+		/** Whether to validate received responses (default: false) */
+		validateResponses?: boolean;
+	};`;
+    }
+    return "";
+  }
+  async generateValidationTypesFile() {
+    const content = this.validationGenerator.generateValidationTypes();
+    return {
+      filename: "validation-types.ts",
+      content,
+      exports: [
+        "ValidationOptions",
+        "ValidationError",
+        "ValidationWarning",
+        "ValidationResult",
+        "ValidationException"
+      ]
+    };
+  }
+  async generateValidatorsFile() {
+    const content = this.validationGenerator.generateResourceValidators();
+    return {
+      filename: "resource-validators.ts",
+      content,
+      exports: [
+        "ResourceValidator",
+        ...Array.from(this.resourceTypes).sort().map((type) => `validate${type}`)
+      ]
+    };
+  }
+  generateCRUDMethods() {
+    const validationEnabled = this.options.includeValidation || this.options.generateValidators;
+    return `	/**
+	 * Create a new FHIR resource
+	 */
+	async create<T extends ResourceTypes>(
+		resource: ResourceTypeMap[T], 
+		options?: RequestOptions
+	): Promise<CreateResponse<ResourceTypeMap[T]>> {
+		const resourceType = resource.resourceType as T;
+		const url = \`\${this.baseUrl}/\${resourceType}\`;
+		
+		${validationEnabled ? this.generateValidationCode("create", "resource") : ""}
+		
+		return this.request<ResourceTypeMap[T]>('POST', url, resource, options);
+	}
+
+	/**
+	 * Read a FHIR resource by ID
+	 */
+	async read<T extends ResourceTypes>(
+		resourceType: T,
+		id: string,
+		options?: RequestOptions
+	): Promise<ReadResponse<ResourceTypeMap[T]>> {
+		const url = \`\${this.baseUrl}/\${resourceType}/\${id}\`;
+		
+		return this.request<ResourceTypeMap[T]>('GET', url, undefined, options);
+	}
+
+	/**
+	 * Update a FHIR resource
+	 */
+	async update<T extends ResourceTypes>(
+		resource: ResourceTypeMap[T],
+		options?: RequestOptions
+	): Promise<UpdateResponse<ResourceTypeMap[T]>> {
+		const resourceType = resource.resourceType as T;
+		const id = (resource as any).id;
+		
+		if (!id) {
+			throw new Error('Resource must have an id to be updated');
+		}
+
+		const url = \`\${this.baseUrl}/\${resourceType}/\${id}\`;
+		
+		${validationEnabled ? this.generateValidationCode("update", "resource") : ""}
+		
+		return this.request<ResourceTypeMap[T]>('PUT', url, resource, options);
+	}
+
+	/**
+	 * Delete a FHIR resource
+	 */
+	async delete<T extends ResourceTypes>(
+		resourceType: T,
+		id: string,
+		options?: RequestOptions
+	): Promise<DeleteResponse> {
+		const url = \`\${this.baseUrl}/\${resourceType}/\${id}\`;
+		
+		return this.request<void>('DELETE', url, undefined, options);
+	}`;
+  }
+  generateValidationCode(operation, resourceVar) {
+    return `// Client-side validation if enabled
+		if (this.config.validation?.enabled && this.config.validation?.validateBeforeRequest) {
+			const validationResult = ResourceValidator.validate(${resourceVar}, {
+				profile: this.config.validation.profile || 'strict',
+				throwOnError: this.config.validation.throwOnError || false,
+				validateRequired: true,
+				validateTypes: true,
+				validateConstraints: true
+			});
+			
+			if (!validationResult.valid && this.config.validation.throwOnError) {
+				throw new ValidationException(validationResult);
+			} else if (!validationResult.valid) {
+				console.warn(\`Validation warnings for \${operation}:\`, validationResult.errors);
+			}
+		}`;
+  }
+  generateSearchMethod() {
+    if (this.options.enhancedSearch) {
+      const autocompleteOverload = this.options.searchAutocomplete ? `
+	async search<T extends ResourceTypes>(
+		resourceType: T,
+		params?: Partial<Record<SearchParamName<T>, any>> & BaseEnhancedSearchParams,
+		options?: RequestOptions
+	): Promise<SearchResponse<ResourceTypeMap[T]>>;` : "";
+      return `	/**
+	 * Search for FHIR resources
+	 */
+	async search<T extends ResourceTypes>(
+		resourceType: T,
+		params?: EnhancedSearchParams<T>,
+		options?: RequestOptions
+	): Promise<SearchResponse<ResourceTypeMap[T]>>;${autocompleteOverload}
+	async search<T extends ResourceTypes>(
+		resourceType: T,
+		params?: SearchParams,
+		options?: RequestOptions
+	): Promise<SearchResponse<ResourceTypeMap[T]>>;
+	async search<T extends ResourceTypes>(
+		resourceType: T,
+		params?: any,
+		options?: RequestOptions
+	): Promise<SearchResponse<ResourceTypeMap[T]>> {
+		let url = \`\${this.baseUrl}/\${resourceType}\`;
+		
+		if (params && Object.keys(params).length > 0) {
+			let searchParams: URLSearchParams | undefined;
+			try {
+				const validation = SearchParameterValidator.validate(resourceType, params);
+				if (validation.valid) {
+					searchParams = SearchParameterValidator.buildSearchParams(resourceType, params);
+				}
+			} catch {}
+			if (!searchParams) {
+				searchParams = new URLSearchParams();
+				for (const [key, value] of Object.entries(params)) {
+					if (Array.isArray(value)) {
+						value.forEach((v) => searchParams!.append(key, String(v)));
+					} else if (value !== undefined) {
+						searchParams.append(key, String(value));
+					}
+				}
+			}
+			url += \`?\${searchParams.toString()}\`;
+		}
+		
+		return this.request<Bundle<ResourceTypeMap[T]>>('GET', url, undefined, options);
+	}`;
+    }
+    const paramHandling = this.generateSearchParameterHandlingCode();
+    return `	/**
+	 * Search for FHIR resources
+	 */
+	async search<T extends ResourceTypes>(
+		resourceType: T,
+		params?: SearchParams,
+		options?: RequestOptions
+	): Promise<SearchResponse<ResourceTypeMap[T]>> {
+		let url = \`\${this.baseUrl}/\${resourceType}\`;
+		
+		if (params && Object.keys(params).length > 0) {
+			${paramHandling}
+			url += \`?\${searchParams.toString()}\`;
+		}
+		
+		return this.request<Bundle<ResourceTypeMap[T]>>('GET', url, undefined, options);
+	}`;
+  }
+  generateValidationMethods() {
+    if (this.options.includeValidation || this.options.generateValidators) {
+      return `
+
+	/**
+	 * Validate a FHIR resource without sending it to the server
+	 */
+	validate<T extends ResourceTypes>(
+		resource: ResourceTypeMap[T],
+		options?: ValidationOptions
+	): ValidationResult {
+		return ResourceValidator.validate(resource, options);
+	}
+
+	/**
+	 * Check if validation is enabled for this client
+	 */
+	isValidationEnabled(): boolean {
+		return this.config.validation?.enabled || false;
+	}
+
+	/**
+	 * Update validation configuration
+	 */
+	updateValidationConfig(validationConfig: NonNullable<${this.options.clientName}Config['validation']>): void {
+		this.config.validation = { ...this.config.validation, ...validationConfig };
+	}`;
+    }
+    return "";
+  }
+  generateSearchParameterHandlingCode() {
+    if (this.options.enhancedSearch) {
+      return `// Use enhanced search parameter validation and building
+			const validation = SearchParameterValidator.validate(resourceType, params);
+			if (!validation.valid) {
+				throw new Error(\`Invalid search parameters: \${validation.errors.join(', ')}\`);
+			}
+			
+			const searchParams = SearchParameterValidator.buildSearchParams(resourceType, params);`;
+    } else {
+      return `const searchParams = new URLSearchParams();
+			for (const [key, value] of Object.entries(params)) {
+				if (Array.isArray(value)) {
+					value.forEach(v => searchParams.append(key, String(v)));
+				} else if (value !== undefined) {
+					searchParams.append(key, String(value));
+				}
+			}`;
+    }
+  }
+  async generateUtilityFile() {
+    const resourceTypesArray = Array.from(this.resourceTypes).sort();
+    const content = `/**
+ * Utility types for FHIR REST Client
+ * 
+ * Shared type definitions and utilities.
+ */
+
+// Import all the resource types
+${resourceTypesArray.map((type) => `import type { ${type} } from '../types/${type}';`).join(`
+`)}
+
+export type ResourceTypes = ${resourceTypesArray.map((type) => `'${type}'`).join(" | ")};
+
+/**
+ * Resource type mapping from resource type strings to interfaces
+ */
+export type ResourceTypeMap = {
+${resourceTypesArray.map((type) => `  '${type}': ${type};`).join(`
+`)}
+};
+`;
+    return {
+      filename: "utility.ts",
+      content,
+      exports: ["ResourceTypes", "ResourceTypeMap", ...resourceTypesArray]
+    };
+  }
+  async ensureDirectoryExists(filePath) {
+    const dir = dirname(filePath);
+    await mkdir2(dir, { recursive: true });
+  }
+}
+
+// src/api/generators/typescript.ts
+import { mkdir as mkdir3, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname2, join as join11 } from "node:path";
+
+// src/utils.ts
+function toPascalCase(input) {
+  const parts = input.replace(/[^A-Za-z0-9]+/g, " ").split(" ").map((p) => p.trim()).filter(Boolean);
+  if (parts.length === 0)
+    return "";
+  return parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+
+// src/api/generators/typescript.ts
+var PRIMITIVE_TYPE_MAP = {
+  string: "string",
+  code: "string",
+  uri: "string",
+  url: "string",
+  canonical: "string",
+  oid: "string",
+  uuid: "string",
+  id: "string",
+  markdown: "string",
+  xhtml: "string",
+  base64Binary: "string",
+  integer: "number",
+  unsignedInt: "number",
+  positiveInt: "number",
+  decimal: "number",
+  boolean: "boolean",
+  date: "string",
+  dateTime: "string",
+  instant: "string",
+  time: "string"
+};
+
+class TypeScriptAPIGenerator {
+  options;
+  imports = new Map;
+  exports = new Set;
+  resourceTypes = new Set;
+  currentSchemaName;
+  profileTypes = new Set;
+  enumTypes = new Map;
+  globalEnumTypes = new Map;
+  fieldEnumMap = new Map;
+  constructor(options) {
+    this.options = {
+      moduleFormat: "esm",
+      generateIndex: true,
+      includeDocuments: true,
+      namingConvention: "PascalCase",
+      includeExtensions: false,
+      includeProfiles: false,
+      ...options
+    };
+  }
+  async transformSchema(schema) {
+    this.currentSchemaName = this.formatTypeName(schema.identifier.name);
+    if (schema.identifier.kind === "value-set" || schema.identifier.kind === "binding" || schema.identifier.kind === "primitive-type") {
+      return;
+    }
+    if (schema.identifier.kind === "profile") {
+      if (this.options.includeProfiles) {
+        return this.generateProfile(schema);
+      }
+      return;
+    }
+    if (this.currentSchemaName === "Uri") {
+      console.log(schema);
+    }
+    this.imports.clear();
+    this.exports.clear();
+    this.currentSchemaName = this.formatTypeName(schema.identifier.name);
+    const content = this.generateTypeScriptForSchema(schema);
+    for (const enumTypeName of this.enumTypes.keys()) {
+      this.imports.set(enumTypeName, "utility");
+    }
+    const imports = new Map(this.imports);
+    const filename = this.getFilename(schema.identifier);
+    const exports = Array.from(this.exports.keys());
+    return {
+      content,
+      imports,
+      exports,
+      filename
+    };
+  }
+  generateTypeScriptForSchema(schema) {
+    const lines = [];
+    this.enumTypes.clear();
+    const interfaceName = this.formatTypeName(schema.identifier.name);
+    let overridedName;
+    if (interfaceName === "Reference") {
+      overridedName = `Reference<T extends ResourceTypes = ResourceTypes>`;
+    } else if (interfaceName === "Bundle") {
+      overridedName = `Bundle<T extends keyof ResourceTypeMap = keyof ResourceTypeMap>`;
+      this.imports.set("ResourceTypeMap", "utility");
+    }
+    this.exports.add(interfaceName);
+    const baseInterface = this.getBaseInterface(schema);
+    if (baseInterface && !baseInterface.isPrimitive) {
+      this.imports.set(baseInterface.value, baseInterface.value);
+      lines.push(`export interface ${overridedName ?? interfaceName} extends ${baseInterface.value} {`);
+    } else {
+      lines.push(`export interface ${overridedName ?? interfaceName} {`);
+    }
+    if (schema.identifier.kind === "resource" && interfaceName !== "DomainResource" && interfaceName !== "Resource") {
+      this.resourceTypes.add(interfaceName);
+      lines.push(`	resourceType: '${interfaceName}';`);
+    }
+    if (isTypeSchemaForResourceComplexTypeLogical(schema)) {
+      if (schema.fields) {
+        for (const [fieldName, field] of Object.entries(schema.fields)) {
+          const fieldLine = this.generateField(fieldName, field, {
+            isNested: "type" in field && field.type.kind === "nested",
+            baseName: interfaceName
+          });
+          if (fieldLine) {
+            lines.push(`	${fieldLine}`);
+          }
+        }
+      }
+      lines.push("}");
+      if (schema.nested) {
+        for (const nested of schema.nested) {
+          lines.push("");
+          lines.push(this.generateNested(this.currentSchemaName ?? "", nested));
+        }
+      }
+    } else {
+      lines.push("}");
+    }
+    return lines.join(`
+`);
+  }
+  generateNested(baseName, nested) {
+    const lines = [];
+    const interfaceName = this.formatTypeName(nested.identifier.name);
+    let fullTypeName = `${baseName}${interfaceName}`;
+    if (fullTypeName === "BundleEntry") {
+      fullTypeName = `BundleEntry<T extends keyof ResourceTypeMap = keyof ResourceTypeMap>`;
+      this.imports.set("ResourceTypeMap", "utility");
+    }
+    this.exports.add(baseName + interfaceName);
+    if (nested.base) {
+      const baseInterface = this.getType(nested.base);
+      if (baseInterface.isPrimitive) {
+        lines.push(`export interface ${fullTypeName}{`);
+      } else {
+        this.imports.set(baseInterface.value, baseInterface.value);
+        lines.push(`export interface ${fullTypeName} extends ${baseInterface.value} {`);
+      }
+    } else {
+      lines.push(`export interface ${fullTypeName}{`);
+    }
+    if (nested.fields) {
+      for (const [fieldName, field] of Object.entries(nested.fields)) {
+        const fieldLine = this.generateField(fieldName, field, {
+          isNested: false,
+          baseName: fullTypeName
+        });
+        if (fieldLine) {
+          lines.push(`	${fieldLine}`);
+        }
+      }
+    }
+    lines.push("}");
+    return lines.join(`
+`);
+  }
+  generateField(fieldName, field, nestedOpts) {
+    if (isPolymorphicInstanceField(field)) {
+      return this.generatePolymorphicInstance(fieldName, field, nestedOpts);
+    } else if (isRegularField(field)) {
+      return this.generateRegularField(fieldName, field, nestedOpts);
+    }
+    return "";
+  }
+  generatePolymorphicInstance(fieldName, field, nestedOpts) {
+    let typeString = "any";
+    if (field.enum) {
+      const enumTypeName = this.generateEnumType(fieldName, field.enum, nestedOpts?.baseName);
+      typeString = enumTypeName;
+    } else if (field.reference) {
+      typeString = this.buildReferenceType(field.reference);
+    } else if (field.type) {
+      const subType = this.getType(field.type);
+      if (!subType.isPrimitive && !nestedOpts?.isNested) {
+        this.imports.set(subType.value, subType.value);
+      }
+      typeString = subType.value;
+    }
+    const optional = !field.required ? "?" : "";
+    const array = field.array ? "[]" : "";
+    return `${fieldName}${optional}: ${nestedOpts?.isNested && nestedOpts.baseName ? nestedOpts.baseName : ""}${typeString}${array};`;
+  }
+  generateRegularField(fieldName, field, nestedOpts) {
+    let typeString = "any";
+    if (field.enum) {
+      const enumTypeName = this.generateEnumType(fieldName, field.enum, nestedOpts?.baseName);
+      typeString = enumTypeName;
+    } else if (field.reference) {
+      typeString = this.buildReferenceType(field.reference);
+    } else if (field.type) {
+      const subType = this.getType(field.type);
+      if (!subType.isPrimitive && !nestedOpts?.isNested) {
+        this.imports.set(subType.value, subType.value);
+      }
+      typeString = subType.value;
+    }
+    if (nestedOpts?.baseName === "Reference" && fieldName === "type") {
+      typeString = "T";
+      this.imports.set("ResourceTypes", "utility");
+    } else if (nestedOpts?.baseName?.startsWith("BundleEntry") && fieldName === "resource") {
+      typeString = "ResourceTypeMap[T]";
+      this.imports.set("ResourceTypeMap", "utility");
+    } else if (this.currentSchemaName === "Bundle" && fieldName === "entry") {
+      typeString = "BundleEntry<T>";
+    }
+    const optional = !field.required ? "?" : "";
+    const array = field.array ? "[]" : "";
+    const shouldAddPrefix = nestedOpts?.isNested && nestedOpts.baseName && !(this.currentSchemaName === "Bundle" && fieldName === "entry");
+    return `${fieldName}${optional}: ${shouldAddPrefix ? nestedOpts.baseName : ""}${typeString}${array};`;
+  }
+  buildReferenceType(refers) {
+    this.imports.set("Reference", "Reference");
+    if (refers.length === 0) {
+      return "Reference";
+    }
+    if (refers.length === 1 && refers[0]?.name === "Resource") {
       return "Reference";
     }
     return `Reference<${refers.map((r) => `'${r.name}'`).join(" | ")}>`;
@@ -3166,31 +5304,51 @@ class TypeScriptAPIGenerator {
     const filteredSchemas = this.filterSchemas(schemas);
     const results = await this.transformSchemas(filteredSchemas);
     const generatedFiles = [];
-    await mkdir2(this.options.outputDir, { recursive: true });
+    await mkdir3(this.options.outputDir, { recursive: true });
     if (this.options.includeProfiles) {
-      await mkdir2(join10(this.options.outputDir, "profiles"), {
+      await mkdir3(join11(this.options.outputDir, "profiles"), {
         recursive: true
       });
     }
     if (this.options.includeExtensions) {
-      await mkdir2(join10(this.options.outputDir, "extensions"), {
+      await mkdir3(join11(this.options.outputDir, "extensions"), {
         recursive: true
       });
     }
+    let utilityContent = `export type ResourceTypes = ${Array.from(this.resourceTypes).map((key) => `'${key}'`).join(" | ")};
+
+`;
+    if (this.globalEnumTypes.size > 0) {
+      utilityContent += `// Shared Enum Types
+
+`;
+      for (const [typeName, enumDef] of this.globalEnumTypes) {
+        if (enumDef.description) {
+          utilityContent += `/**
+ * ${enumDef.description}
+ */
+`;
+        }
+        const unionType = enumDef.values.map((v) => `'${v}'`).join(" | ");
+        utilityContent += `export type ${typeName} = ${unionType};
+
+`;
+      }
+    }
     results.push({
       filename: "utility.ts",
-      content: `export type ResourceTypes = ${Array.from(this.resourceTypes.keys().map((key) => `'${key}'`)).join(" | ")};
-
-`,
+      content: utilityContent,
       imports: new Map,
-      exports: ["ResourceTypes"]
+      exports: ["ResourceTypes", ...Array.from(this.globalEnumTypes.keys())]
     });
     for (const result of results) {
-      const filePath = join10(this.options.outputDir, result.filename);
+      const filePath = join11(this.options.outputDir, result.filename);
       await this.ensureDirectoryExists(filePath);
-      await writeFile4(filePath, `${this.generateImportStatements(result.imports)}
+      const imports = result.filename === "utility.ts" ? "" : this.generateImportStatements(result.imports);
+      const content = imports ? `${imports}
 
-${result.content}`, "utf-8");
+${result.content}` : result.content;
+      await writeFile5(filePath, content, "utf-8");
       generatedFiles.push({
         path: filePath,
         filename: result.filename,
@@ -3200,8 +5358,8 @@ ${result.content}`, "utf-8");
     }
     if (this.options.generateIndex) {
       const indexFile = await this.generateIndexFile(results);
-      const indexPath = join10(this.options.outputDir, "index.ts");
-      await writeFile4(indexPath, indexFile.content, "utf-8");
+      const indexPath = join11(this.options.outputDir, "index.ts");
+      await writeFile5(indexPath, indexFile.content, "utf-8");
       generatedFiles.push({
         path: indexPath,
         filename: "index.ts",
@@ -3214,8 +5372,22 @@ ${result.content}`, "utf-8");
   }
   generateImportStatements(imports) {
     const lines = [];
-    for (const [item, pkg] of imports.entries()) {
-      lines.push(`import type { ${item} } from './${pkg}';`);
+    const importsByPackage = new Map;
+    for (const [item, pkg] of imports) {
+      if (!importsByPackage.has(pkg)) {
+        importsByPackage.set(pkg, []);
+      }
+      importsByPackage.get(pkg).push(item);
+    }
+    for (const [pkg, items] of importsByPackage) {
+      if (items.length === 1) {
+        lines.push(`import type { ${items[0]} } from './${pkg}';`);
+      } else {
+        lines.push(`import type {
+	${items.join(`,
+	`)}
+} from './${pkg}';`);
+      }
     }
     return lines.join(`
 `);
@@ -3226,7 +5398,7 @@ ${result.content}`, "utf-8");
     const generatedFiles = [];
     for (const result of results) {
       generatedFiles.push({
-        path: join10(this.options.outputDir, result.filename),
+        path: join11(this.options.outputDir, result.filename),
         filename: result.filename,
         content: result.content,
         exports: result.exports
@@ -3235,7 +5407,7 @@ ${result.content}`, "utf-8");
     if (this.options.generateIndex) {
       const indexFile = await this.generateIndexFile(results);
       generatedFiles.push({
-        path: join10(this.options.outputDir, "index.ts"),
+        path: join11(this.options.outputDir, "index.ts"),
         filename: "index.ts",
         content: indexFile.content,
         exports: indexFile.exports
@@ -3270,14 +5442,14 @@ ${result.content}`, "utf-8");
     const valueSets = [];
     for (const result of results) {
       for (const exportName of result.exports) {
-        if (result.filename.includes("primitive")) {
+        if (result.filename.includes("profiles/")) {
+          profiles.push(exportName);
+        } else if (result.filename.includes("primitive")) {
           primitiveTypes.push(exportName);
         } else if (result.filename.includes("complex")) {
           complexTypes.push(exportName);
         } else if (result.filename.includes("resource")) {
           resources.push(exportName);
-        } else if (result.filename.includes("profile")) {
-          profiles.push(exportName);
         } else if (result.filename.includes("valueset")) {
           valueSets.push(exportName);
         } else {
@@ -3285,7 +5457,7 @@ ${result.content}`, "utf-8");
         }
       }
       const baseName = result.filename.replace(".ts", "");
-      if (baseName.startsWith("valueset") || baseName.startsWith("extension") || baseName.startsWith("profile")) {
+      if (baseName.startsWith("valueset") || baseName.startsWith("extension") || baseName.startsWith("profiles/")) {
         continue;
       }
       if (result.exports.length > 0) {
@@ -3335,103 +5507,463 @@ ${result.content}`, "utf-8");
     lines.push("// Value sets namespace - contains all FHIR ValueSet types and bindings");
     lines.push('export * as ValueSets from "./valuesets";');
     lines.push("");
-    if (this.options.includeExtensions) {
-      lines.push("// Extensions namespace - contains all FHIR Extension types");
-      lines.push('export * as Extensions from "./extensions";');
+    if (this.options.includeExtensions) {
+      lines.push("// Extensions namespace - contains all FHIR Extension types");
+      lines.push('export * as Extensions from "./extensions";');
+      lines.push("");
+    }
+    if (this.options.includeProfiles) {
+      lines.push("// Profiles namespace - contains all FHIR Profile types");
+      lines.push('export * as Profiles from "./profiles";');
+      lines.push("");
+    }
+    const content = lines.join(`
+`);
+    return { content, exports };
+  }
+  async ensureDirectoryExists(filePath) {
+    const dir = dirname2(filePath);
+    await mkdir3(dir, { recursive: true });
+  }
+  filterSchemas(schemas) {
+    if (this.options.includeExtensions) {
+      return schemas;
+    }
+    return schemas;
+  }
+  async generateSubfolderIndexFiles(results, generatedFiles) {
+    const subfolders = [];
+    if (this.options.includeExtensions) {
+      subfolders.push("extensions");
+    }
+    if (this.options.includeProfiles) {
+      subfolders.push("profiles");
+    }
+    for (const subfolder of subfolders) {
+      const subfolderResults = results.filter((r) => r.filename.startsWith(`${subfolder}/`));
+      const indexContent = this.generateSubfolderIndex(subfolderResults, subfolder);
+      const indexPath = join11(this.options.outputDir, subfolder, "index.ts");
+      await writeFile5(indexPath, indexContent, "utf-8");
+      generatedFiles.push({
+        path: indexPath,
+        filename: `${subfolder}/index.ts`,
+        content: indexContent,
+        exports: subfolderResults.flatMap((r) => r.exports)
+      });
+    }
+  }
+  generateSubfolderIndex(results, subfolder) {
+    const lines = [];
+    lines.push("/**");
+    lines.push(` * ${subfolder.charAt(0).toUpperCase() + subfolder.slice(1)} Index`);
+    lines.push(" * ");
+    lines.push(" * Auto-generated exports for all types in this subfolder.");
+    lines.push(" */");
+    lines.push("");
+    if (results.length === 0) {
+      lines.push("// No types in this category");
+      lines.push("export {};");
+      return lines.join(`
+`);
+    }
+    for (const result of results) {
+      const baseName = result.filename.replace(`${subfolder}/`, "").replace(".ts", "");
+      if (result.exports.length > 0) {
+        if (result.exports.length === 1) {
+          lines.push(`export type { ${result.exports[0]} } from './${baseName}';`);
+        } else {
+          lines.push(`export type {`);
+          for (let i = 0;i < result.exports.length; i++) {
+            const exportName = result.exports[i];
+            const isLast = i === result.exports.length - 1;
+            lines.push(`  ${exportName}${isLast ? "" : ","}`);
+          }
+          lines.push(`} from './${baseName}';`);
+        }
+      }
+    }
+    return lines.join(`
+`);
+  }
+  formatTypeName(name) {
+    if (this.options.namingConvention === "PascalCase") {
+      return toPascalCase(name);
+    }
+    return name;
+  }
+  getType(identifier) {
+    const primitiveType = PRIMITIVE_TYPE_MAP[identifier.name];
+    if (primitiveType) {
+      return { isPrimitive: true, value: primitiveType };
+    }
+    return { isPrimitive: false, value: this.formatTypeName(identifier.name) };
+  }
+  getBaseInterface(schema) {
+    if ((isTypeSchemaForResourceComplexTypeLogical(schema) || schema.identifier.kind === "profile") && schema.base) {
+      return this.getType(schema.base);
+    }
+    return null;
+  }
+  getFilename(identifier) {
+    const name = toPascalCase(identifier.name);
+    if (identifier.kind === "profile" && this.options.includeProfiles) {
+      const subfolder = "profiles";
+      return `${subfolder}/${name}.ts`;
+    }
+    return `${name}.ts`;
+  }
+  async generateProfile(schema) {
+    this.imports.clear();
+    this.exports.clear();
+    this.currentSchemaName = this.formatTypeName(schema.identifier.name);
+    this.profileTypes.add(this.currentSchemaName);
+    const content = this.generateTypeScriptForProfile(schema);
+    const imports = new Map(this.imports);
+    const filename = this.getFilename(schema.identifier);
+    const exports = Array.from(this.exports.keys());
+    return {
+      content,
+      imports,
+      exports,
+      filename
+    };
+  }
+  generateTypeScriptForProfile(schema) {
+    const lines = [];
+    const interfaceName = this.formatTypeName(schema.identifier.name);
+    if (schema.description) {
+      lines.push("/**");
+      lines.push(` * ${schema.description}`);
+      lines.push(` * @profile ${schema.identifier.url}`);
+      lines.push(" */");
+    }
+    this.exports.add(interfaceName);
+    const baseInterface = this.getBaseInterface(schema);
+    if (baseInterface && !baseInterface.isPrimitive) {
+      const importPath = baseInterface.value;
+      this.imports.set(baseInterface.value, `../${importPath}`);
+      lines.push(`export interface ${interfaceName} extends ${baseInterface.value} {`);
+    } else {
+      lines.push(`export interface ${interfaceName} {`);
+    }
+    if (isTypeSchemaForResourceComplexTypeLogical(schema) || schema.identifier.kind === "profile") {
+      if (schema.constraints && Object.keys(schema.constraints).length > 0) {
+        for (const [path9, constraint] of Object.entries(schema.constraints)) {
+          const fieldName = path9.includes(".") ? path9.split(".").pop() : path9;
+          if (!fieldName)
+            continue;
+          if (constraint.min && constraint.min > 0) {
+            const field = schema.fields?.[fieldName];
+            if (field) {
+              const fieldLine = this.generateProfileField(fieldName, field, schema);
+              if (fieldLine) {
+                lines.push(`	${fieldLine}`);
+              }
+            }
+          }
+        }
+      }
+      lines.push("}");
+      if (schema.nested) {
+        for (const nested of schema.nested) {
+          lines.push("");
+          lines.push(this.generateNested(this.currentSchemaName ?? "", nested));
+        }
+      }
+    } else {
+      lines.push("}");
+    }
+    if (this.options.includeProfiles) {
+      lines.push("");
+      lines.push(this.generateProfileValidator(interfaceName, schema));
+    }
+    lines.push("");
+    lines.push(this.generateProfileTypeGuard(interfaceName, schema));
+    return lines.join(`
+`);
+  }
+  generateProfileField(fieldName, field, schema) {
+    let typeString = "any";
+    let required = false;
+    let array = false;
+    if (isRegularField(field)) {
+      required = field.required || false;
+      array = field.array || false;
+      if (field.enum) {
+        const enumTypeName = this.generateEnumType(fieldName, field.enum, this.currentSchemaName);
+        typeString = enumTypeName;
+      } else if (field.reference) {
+        typeString = this.buildReferenceType(field.reference);
+      } else if (field.type) {
+        const subType = this.getType(field.type);
+        if (!subType.isPrimitive) {
+          this.imports.set(subType.value, `../${subType.value}`);
+        }
+        typeString = subType.value;
+      }
+    } else if (isPolymorphicInstanceField(field)) {
+      required = field.required || false;
+      array = field.array || false;
+      if (field.reference) {
+        typeString = this.buildReferenceType(field.reference);
+      } else if (field.type) {
+        const subType = this.getType(field.type);
+        if (!subType.isPrimitive) {
+          this.imports.set(subType.value, `../${subType.value}`);
+        }
+        typeString = subType.value;
+      }
+    } else if ("choices" in field) {
+      required = field.required || false;
+      array = field.array || false;
+      return "";
+    }
+    if (schema.constraints && schema.constraints[fieldName]) {
+      const constraint = schema.constraints[fieldName];
+      if (constraint.min && constraint.min > 0) {
+        required = true;
+      }
+      if (constraint.max === "*") {
+        array = true;
+      }
+    }
+    const optional = !required ? "?" : "";
+    const arrayType = array ? "[]" : "";
+    return `${fieldName}${optional}: ${typeString}${arrayType};`;
+  }
+  generateProfileValidator(interfaceName, schema) {
+    const lines = [];
+    const validatorName = `validate${interfaceName}`;
+    lines.push("/**");
+    lines.push(` * Validate a resource against the ${interfaceName} profile`);
+    lines.push(" */");
+    lines.push(`export function ${validatorName}(resource: unknown): ValidationResult {`);
+    lines.push("\tconst errors: string[] = [];");
+    lines.push("");
+    const baseInterface = this.getBaseInterface(schema);
+    if (baseInterface && !baseInterface.isPrimitive) {
+      this.imports.set(`is${baseInterface.value}`, `../${baseInterface.value}`);
+      lines.push(`	// Validate base resource`);
+      lines.push(`	if (!is${baseInterface.value}(resource)) {`);
+      lines.push(`		return { valid: false, errors: ['Not a valid ${baseInterface.value} resource'] };`);
+      lines.push("\t}");
+      lines.push("");
+      lines.push(`	const typed = resource as ${baseInterface.value};`);
       lines.push("");
     }
-    if (profiles.length > 0) {
-      lines.push("// Profiles namespace - contains all FHIR Profile types");
-      lines.push('export * as Profiles from "./profiles";');
+    if (schema.constraints) {
+      lines.push("\t// Profile constraint validation");
+      for (const [path9, constraint] of Object.entries(schema.constraints)) {
+        this.generateConstraintValidation(lines, path9, constraint);
+      }
       lines.push("");
     }
-    const content = lines.join(`
+    if (schema.constraints) {
+      const mustSupportFields = [];
+      for (const [path9, constraint] of Object.entries(schema.constraints)) {
+        if (constraint.mustSupport) {
+          mustSupportFields.push(path9);
+        }
+      }
+      if (mustSupportFields.length > 0) {
+        lines.push("\t// Must Support elements validation");
+        for (const field of mustSupportFields) {
+          lines.push(`	// Must support: ${field}`);
+          lines.push(`	// Note: Must Support validation is context-dependent`);
+        }
+        lines.push("");
+      }
+    }
+    lines.push("\treturn {");
+    lines.push("\t\tvalid: errors.length === 0,");
+    lines.push("\t\terrors");
+    lines.push("\t};");
+    lines.push("}");
+    this.imports.set("ValidationResult", "../types");
+    return lines.join(`
 `);
-    return { content, exports };
-  }
-  async ensureDirectoryExists(filePath) {
-    const dir = dirname(filePath);
-    await mkdir2(dir, { recursive: true });
   }
-  filterSchemas(schemas) {
-    if (this.options.includeExtensions) {
-      return schemas;
+  generateConstrainedProfileField(path9, constraint, schema) {
+    const fieldPath = path9.includes(".") ? path9.split(".").pop() : path9;
+    if (!fieldPath)
+      return "";
+    let typeString = "any";
+    let required = false;
+    let array = false;
+    if (constraint.min !== undefined && constraint.min > 0) {
+      required = true;
     }
-    return schemas;
-  }
-  async generateSubfolderIndexFiles(results, generatedFiles) {
-    const subfolders = [];
-    if (this.options.includeExtensions) {
-      subfolders.push("extensions");
+    if (constraint.max === "*") {
+      array = true;
     }
-    for (const subfolder of subfolders) {
-      const subfolderResults = results.filter((r) => r.filename.startsWith(`${subfolder}/`));
-      const indexContent = this.generateSubfolderIndex(subfolderResults, subfolder);
-      const indexPath = join10(this.options.outputDir, subfolder, "index.ts");
-      await writeFile4(indexPath, indexContent, "utf-8");
-      generatedFiles.push({
-        path: indexPath,
-        filename: `${subfolder}/index.ts`,
-        content: indexContent,
-        exports: subfolderResults.flatMap((r) => r.exports)
+    switch (fieldPath) {
+      case "status":
+        typeString = "string";
+        break;
+      case "category":
+        typeString = "CodeableConcept";
+        array = true;
+        this.imports.set("CodeableConcept", "../CodeableConcept");
+        break;
+      case "code":
+        typeString = "CodeableConcept";
+        this.imports.set("CodeableConcept", "../CodeableConcept");
+        break;
+      case "subject":
+        typeString = "Reference";
+        this.imports.set("Reference", "../Reference");
+        break;
+      case "effective":
+      case "effectiveDateTime":
+        typeString = "string";
+        break;
+      case "effectivePeriod":
+        typeString = "Period";
+        this.imports.set("Period", "../Period");
+        break;
+      case "dataAbsentReason":
+        typeString = "CodeableConcept";
+        this.imports.set("CodeableConcept", "../CodeableConcept");
+        break;
+      case "component":
+        typeString = "any";
+        array = true;
+        break;
+      default:
+        if (constraint.binding && constraint.binding.strength === "required") {
+          typeString = "string";
+        }
+    }
+    if (constraint.fixedValue !== undefined) {
+      if (typeof constraint.fixedValue === "string") {
+        typeString = `'${constraint.fixedValue}'`;
+      } else {
+        typeString = JSON.stringify(constraint.fixedValue);
+      }
+    }
+    const optional = !required ? "?" : "";
+    const arrayType = array ? "[]" : "";
+    return `${fieldPath}${optional}: ${typeString}${arrayType};`;
+  }
+  generateConstraintValidation(lines, path9, constraint) {
+    const fieldPath = path9.includes(".") ? path9.split(".").pop() : path9;
+    if (constraint.min !== undefined && constraint.min > 0) {
+      if (constraint.min === 1) {
+        lines.push(`	if (!typed.${fieldPath}) {`);
+        lines.push(`		errors.push('${fieldPath} is required for this profile');`);
+        lines.push("\t}");
+      } else {
+        lines.push(`	if (!typed.${fieldPath} || (Array.isArray(typed.${fieldPath}) && typed.${fieldPath}.length < ${constraint.min})) {`);
+        lines.push(`		errors.push('${fieldPath} must have at least ${constraint.min} item(s)');`);
+        lines.push("\t}");
+      }
+    }
+    if (constraint.fixedValue !== undefined) {
+      const fixedValue = typeof constraint.fixedValue === "string" ? `'${constraint.fixedValue}'` : JSON.stringify(constraint.fixedValue);
+      lines.push(`	if (typed.${fieldPath} !== ${fixedValue}) {`);
+      lines.push(`		errors.push('${fieldPath} must have fixed value ${fixedValue}');`);
+      lines.push("\t}");
+    }
+    if (constraint.binding && constraint.binding.strength === "required") {
+      lines.push(`	// Required binding validation for ${fieldPath}`);
+      lines.push(`	// Note: Full value set validation requires external value set service`);
+    }
+  }
+  generateEnumType(fieldName, enumValues, baseName) {
+    const prefix = baseName || this.currentSchemaName || "";
+    const enumTypeName = `${prefix}${this.toPascalCase(fieldName)}Values`;
+    if (!this.enumTypes.has(enumTypeName)) {
+      this.enumTypes.set(enumTypeName, {
+        values: enumValues,
+        description: `Valid values for ${fieldName} field in ${prefix}`
       });
+      this.exports.add(enumTypeName);
+      if (!this.globalEnumTypes.has(enumTypeName)) {
+        this.globalEnumTypes.set(enumTypeName, {
+          values: enumValues,
+          description: `Valid values for ${fieldName} field in ${prefix}`
+        });
+      }
     }
+    return enumTypeName;
   }
-  generateSubfolderIndex(results, subfolder) {
+  generateEnumTypes() {
     const lines = [];
-    lines.push("/**");
-    lines.push(` * ${subfolder.charAt(0).toUpperCase() + subfolder.slice(1)} Index`);
-    lines.push(" * ");
-    lines.push(" * Auto-generated exports for all types in this subfolder.");
-    lines.push(" */");
-    lines.push("");
-    if (results.length === 0) {
-      lines.push("// No types in this category");
-      lines.push("export {};");
-      return lines.join(`
-`);
-    }
-    for (const result of results) {
-      const baseName = result.filename.replace(`${subfolder}/`, "").replace(".ts", "");
-      if (result.exports.length > 0) {
-        if (result.exports.length === 1) {
-          lines.push(`export type { ${result.exports[0]} } from './${baseName}';`);
-        } else {
-          lines.push(`export type {`);
-          for (let i = 0;i < result.exports.length; i++) {
-            const exportName = result.exports[i];
-            const isLast = i === result.exports.length - 1;
-            lines.push(`  ${exportName}${isLast ? "" : ","}`);
-          }
-          lines.push(`} from './${baseName}';`);
+    if (this.enumTypes.size > 0) {
+      lines.push("// Enum Types");
+      lines.push("");
+      for (const [typeName, enumDef] of this.enumTypes) {
+        if (enumDef.description) {
+          lines.push("/**");
+          lines.push(` * ${enumDef.description}`);
+          lines.push(" */");
         }
+        const unionType = enumDef.values.map((v) => `'${v}'`).join(" | ");
+        lines.push(`export type ${typeName} = ${unionType};`);
+        lines.push("");
       }
     }
     return lines.join(`
 `);
   }
-  formatTypeName(name) {
-    if (this.options.namingConvention === "PascalCase") {
-      return toPascalCase(name);
-    }
-    return name;
+  toPascalCase(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
   }
-  getType(identifier) {
-    const primitiveType = PRIMITIVE_TYPE_MAP[identifier.name];
-    if (primitiveType) {
-      return { isPrimitive: true, value: primitiveType };
+  generateProfileTypeGuard(interfaceName, schema) {
+    const lines = [];
+    const guardName = `is${interfaceName}`;
+    lines.push("/**");
+    lines.push(` * Type guard for ${interfaceName} profile`);
+    lines.push(" */");
+    lines.push(`export function ${guardName}(resource: unknown): resource is ${interfaceName} {`);
+    const baseInterface = this.getBaseInterface(schema);
+    if (baseInterface && !baseInterface.isPrimitive) {
+      this.imports.set(`is${baseInterface.value}`, `../${baseInterface.value}`);
+      lines.push(`	if (!is${baseInterface.value}(resource)) return false;`);
+      lines.push("");
+      lines.push(`	const typed = resource as ${baseInterface.value};`);
+    } else {
+      lines.push(`	if (!resource || typeof resource !== 'object') return false;`);
+      lines.push("");
+      lines.push("\tconst typed = resource as any;");
+    }
+    if (schema.constraints) {
+      lines.push("\t// Profile constraint checks");
+      let hasRequiredChecks = false;
+      for (const [path9, constraint] of Object.entries(schema.constraints)) {
+        const fieldPath = path9.includes(".") ? path9.split(".").pop() : path9;
+        if (constraint.min !== undefined && constraint.min > 0) {
+          hasRequiredChecks = true;
+          if (constraint.min === 1) {
+            lines.push(`	if (!typed.${fieldPath}) return false;`);
+          } else {
+            lines.push(`	if (!typed.${fieldPath} || (Array.isArray(typed.${fieldPath}) && typed.${fieldPath}.length < ${constraint.min})) return false;`);
+          }
+        }
+        if (constraint.fixedValue !== undefined) {
+          hasRequiredChecks = true;
+          const fixedValue = typeof constraint.fixedValue === "string" ? `'${constraint.fixedValue}'` : JSON.stringify(constraint.fixedValue);
+          lines.push(`	if (typed.${fieldPath} !== ${fixedValue}) return false;`);
+        }
+      }
+      if (hasRequiredChecks) {
+        lines.push("");
+      }
     }
-    return { isPrimitive: false, value: this.formatTypeName(identifier.name) };
-  }
-  getBaseInterface(schema) {
-    if (isTypeSchemaForResourceComplexTypeLogical(schema) && schema.base) {
-      return this.getType(schema.base);
+    if (schema.extensions && schema.extensions.length > 0) {
+      lines.push("\t// Extension presence checks (simplified)");
+      for (const ext of schema.extensions) {
+        if (ext.min && ext.min > 0) {
+          lines.push(`	// Required extension: ${ext.profile}`);
+          lines.push(`	// Note: Full extension validation requires examining extension array`);
+        }
+      }
+      lines.push("");
     }
-    return null;
-  }
-  getFilename(identifier) {
-    const name = toPascalCase(identifier.name);
-    return `${name}.ts`;
+    lines.push("\treturn true;");
+    lines.push("}");
+    return lines.join(`
+`);
   }
 }
 
@@ -3502,6 +6034,23 @@ class APIBuilder {
     }, "typescript");
     return this;
   }
+  restClient(options = {}) {
+    const clientOutputDir = `${this.options.outputDir}/client`;
+    const generator = new RestClientGenerator({
+      outputDir: clientOutputDir,
+      ...options
+    });
+    this.generators.set("restclient", generator);
+    this.logger.info("Configured REST client generator", {
+      outputDir: clientOutputDir,
+      clientName: options.clientName || "FHIRClient",
+      includeValidation: options.includeValidation ?? false,
+      includeErrorHandling: options.includeErrorHandling ?? true,
+      enhancedSearch: options.enhancedSearch ?? false,
+      useCanonicalManager: options.useCanonicalManager ?? true
+    }, "restclient");
+    return this;
+  }
   onProgress(callback) {
     this.progressCallback = callback;
     return this;
@@ -3524,7 +6073,21 @@ class APIBuilder {
     this.options.validate = enabled;
     return this;
   }
+  ensureTypeScriptForRestClient() {
+    const hasRestClient = this.generators.has("restclient");
+    const hasTypeScript = this.generators.has("typescript");
+    if (hasRestClient && !hasTypeScript) {
+      this.logger.info("Automatically adding TypeScript generator for REST client", {}, "ensureTypeScriptForRestClient");
+      this.typescript({
+        moduleFormat: "esm",
+        generateIndex: true,
+        includeDocuments: false,
+        namingConvention: "PascalCase"
+      });
+    }
+  }
   async generate() {
+    this.ensureTypeScriptForRestClient();
     const startTime = performance.now();
     const result = {
       success: false,
@@ -3659,6 +6222,32 @@ class APIBuilder {
 function createAPI(options) {
   return new APIBuilder(options);
 }
+function createAPIFromConfig(config) {
+  const builder = new APIBuilder({
+    outputDir: config.outputDir,
+    verbose: config.verbose,
+    overwrite: config.overwrite,
+    validate: config.validate,
+    cache: config.cache,
+    typeSchemaConfig: config.typeSchema
+  });
+  if (config.packages && config.packages.length > 0) {
+    for (const pkg of config.packages) {
+      builder.fromPackage(pkg);
+    }
+  }
+  if (config.files && config.files.length > 0) {
+    builder.fromFiles(...config.files);
+  }
+  if (config.typescript) {
+    builder.typescript(config.typescript);
+  }
+  if (config.restClient) {
+    console.log("fsdfdsfsdfdsf");
+    builder.restClient(config.restClient);
+  }
+  return builder;
+}
 async function generateTypesFromPackage(packageName, outputDir, options = {}) {
   return createAPI({
     outputDir,
@@ -3683,6 +6272,24 @@ var DEFAULT_CONFIG = {
   overwrite: true,
   validate: true,
   cache: true,
+  restClient: {
+    clientName: "FHIRClient",
+    includeValidation: false,
+    includeErrorHandling: true,
+    includeRequestInterceptors: false,
+    baseUrlOverride: "",
+    enhancedSearch: false,
+    chainedSearchBuilder: false,
+    searchAutocomplete: true,
+    generateValueSetEnums: true,
+    includeUtilities: true,
+    generateValidators: false,
+    useCanonicalManager: true,
+    defaultTimeout: 30000,
+    defaultRetries: 0,
+    includeDocumentation: true,
+    generateExamples: false
+  },
   typescript: {
     moduleFormat: "esm",
     generateIndex: true,
@@ -3699,6 +6306,14 @@ var DEFAULT_CONFIG = {
     fhirVersion: "R4",
     resourceTypes: [],
     maxDepth: 10,
+    profileOptions: {
+      generateKind: "interface",
+      includeConstraints: true,
+      includeDocumentation: true,
+      generateValidators: true,
+      strictMode: false,
+      subfolder: "profiles"
+    },
     generateBuilders: false,
     builderOptions: {
       includeValidation: true,
@@ -3745,7 +6360,11 @@ var DEFAULT_CONFIG = {
     validateCached: true,
     forceRegenerate: false,
     shareCache: true,
-    cacheKeyPrefix: ""
+    cacheKeyPrefix: "",
+    profiles: {
+      packages: [],
+      autoDetect: true
+    }
   },
   packages: [],
   files: [],
@@ -3800,6 +6419,14 @@ class ConfigValidator {
       const tsErrors = this.validateTypeScriptConfig(cfg.typescript);
       result.errors.push(...tsErrors);
     }
+    if (cfg.typeSchema !== undefined) {
+      const tsErrors = this.validateTypeSchemaConfig(cfg.typeSchema);
+      result.errors.push(...tsErrors);
+    }
+    if (cfg.restClient !== undefined) {
+      const rcErrors = this.validateRestClientConfig(cfg.restClient);
+      result.errors.push(...rcErrors);
+    }
     if (cfg.packages !== undefined) {
       if (!Array.isArray(cfg.packages)) {
         result.errors.push({
@@ -3899,6 +6526,10 @@ class ConfigValidator {
       const guardErrors = this.validateGuardOptions(cfg.guardOptions);
       errors.push(...guardErrors);
     }
+    if (cfg.profileOptions !== undefined) {
+      const profileErrors = this.validateProfileOptions(cfg.profileOptions);
+      errors.push(...profileErrors);
+    }
     return errors;
   }
   validateValidatorOptions(config) {
@@ -3938,6 +6569,74 @@ class ConfigValidator {
     }
     return errors;
   }
+  validateRestClientConfig(config) {
+    const errors = [];
+    if (typeof config !== "object" || config === null) {
+      errors.push({
+        path: "restClient",
+        message: "restClient config must be an object",
+        value: config
+      });
+      return errors;
+    }
+    const cfg = config;
+    if (cfg.clientName !== undefined && typeof cfg.clientName !== "string") {
+      errors.push({
+        path: "restClient.clientName",
+        message: "clientName must be a string",
+        value: cfg.clientName
+      });
+    }
+    if (cfg.baseUrlOverride !== undefined && typeof cfg.baseUrlOverride !== "string") {
+      errors.push({
+        path: "restClient.baseUrlOverride",
+        message: "baseUrlOverride must be a string",
+        value: cfg.baseUrlOverride
+      });
+    }
+    if (cfg.defaultTimeout !== undefined) {
+      if (typeof cfg.defaultTimeout !== "number" || cfg.defaultTimeout <= 0) {
+        errors.push({
+          path: "restClient.defaultTimeout",
+          message: "defaultTimeout must be a positive number",
+          value: cfg.defaultTimeout
+        });
+      }
+    }
+    if (cfg.defaultRetries !== undefined) {
+      if (typeof cfg.defaultRetries !== "number" || cfg.defaultRetries < 0) {
+        errors.push({
+          path: "restClient.defaultRetries",
+          message: "defaultRetries must be a non-negative number",
+          value: cfg.defaultRetries
+        });
+      }
+    }
+    const booleanFields = [
+      "includeValidation",
+      "includeErrorHandling",
+      "includeRequestInterceptors",
+      "enhancedSearch",
+      "chainedSearchBuilder",
+      "searchAutocomplete",
+      "generateValueSetEnums",
+      "includeUtilities",
+      "generateValidators",
+      "useCanonicalManager",
+      "includeDocumentation",
+      "generateExamples"
+    ];
+    for (const field of booleanFields) {
+      if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
+        errors.push({
+          path: `restClient.${field}`,
+          message: `${field} must be a boolean`,
+          value: cfg[field]
+        });
+      }
+    }
+    return errors;
+  }
   validateGuardOptions(config) {
     const errors = [];
     if (typeof config !== "object" || config === null) {
@@ -3977,6 +6676,134 @@ class ConfigValidator {
     }
     return errors;
   }
+  validateProfileOptions(config) {
+    const errors = [];
+    if (typeof config !== "object" || config === null) {
+      errors.push({
+        path: "typescript.profileOptions",
+        message: "profileOptions must be an object",
+        value: config
+      });
+      return errors;
+    }
+    const cfg = config;
+    if (cfg.generateKind !== undefined) {
+      if (!["interface", "type", "both"].includes(cfg.generateKind)) {
+        errors.push({
+          path: "typescript.profileOptions.generateKind",
+          message: 'generateKind must be "interface", "type", or "both"',
+          value: cfg.generateKind
+        });
+      }
+    }
+    if (cfg.subfolder !== undefined && typeof cfg.subfolder !== "string") {
+      errors.push({
+        path: "typescript.profileOptions.subfolder",
+        message: "subfolder must be a string",
+        value: cfg.subfolder
+      });
+    }
+    const booleanFields = [
+      "includeConstraints",
+      "includeDocumentation",
+      "generateValidators",
+      "strictMode"
+    ];
+    for (const field of booleanFields) {
+      if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
+        errors.push({
+          path: `typescript.profileOptions.${field}`,
+          message: `${field} must be a boolean`,
+          value: cfg[field]
+        });
+      }
+    }
+    return errors;
+  }
+  validateTypeSchemaConfig(config) {
+    const errors = [];
+    if (typeof config !== "object" || config === null) {
+      errors.push({
+        path: "typeSchema",
+        message: "typeSchema config must be an object",
+        value: config
+      });
+      return errors;
+    }
+    const cfg = config;
+    const booleanFields = [
+      "enablePersistence",
+      "validateCached",
+      "forceRegenerate",
+      "shareCache"
+    ];
+    for (const field of booleanFields) {
+      if (cfg[field] !== undefined && typeof cfg[field] !== "boolean") {
+        errors.push({
+          path: `typeSchema.${field}`,
+          message: `${field} must be a boolean`,
+          value: cfg[field]
+        });
+      }
+    }
+    const stringFields = ["cacheDir", "cacheKeyPrefix"];
+    for (const field of stringFields) {
+      if (cfg[field] !== undefined && typeof cfg[field] !== "string") {
+        errors.push({
+          path: `typeSchema.${field}`,
+          message: `${field} must be a string`,
+          value: cfg[field]
+        });
+      }
+    }
+    if (cfg.maxAge !== undefined) {
+      if (typeof cfg.maxAge !== "number" || cfg.maxAge <= 0) {
+        errors.push({
+          path: "typeSchema.maxAge",
+          message: "maxAge must be a positive number",
+          value: cfg.maxAge
+        });
+      }
+    }
+    if (cfg.profiles !== undefined) {
+      if (typeof cfg.profiles !== "object" || cfg.profiles === null) {
+        errors.push({
+          path: "typeSchema.profiles",
+          message: "profiles must be an object",
+          value: cfg.profiles
+        });
+      } else {
+        const profiles = cfg.profiles;
+        if (profiles.packages !== undefined) {
+          if (!Array.isArray(profiles.packages)) {
+            errors.push({
+              path: "typeSchema.profiles.packages",
+              message: "packages must be an array",
+              value: profiles.packages
+            });
+          } else {
+            profiles.packages.forEach((pkg, index) => {
+              if (typeof pkg !== "string") {
+                errors.push({
+                  path: `typeSchema.profiles.packages[${index}]`,
+                  message: "package name must be a string",
+                  value: pkg
+                });
+              }
+            });
+          }
+        }
+        if (profiles.autoDetect !== undefined && typeof profiles.autoDetect !== "boolean") {
+          errors.push({
+            path: "typeSchema.profiles.autoDetect",
+            message: "autoDetect must be a boolean",
+            value: profiles.autoDetect
+          });
+        }
+      }
+    }
+    return errors;
+  }
 }
 
 class ConfigLoader {
@@ -4030,6 +6857,10 @@ ${errorMessages}`);
       typescript: {
         ...DEFAULT_CONFIG.typescript,
         ...userConfig.typescript
+      },
+      restClient: {
+        ...DEFAULT_CONFIG.restClient,
+        ...userConfig.restClient
       }
     };
   }
@@ -4044,4 +6875,4 @@ function isConfig(obj) {
   return result.valid;
 }
 
-export { __toESM, __commonJS, __require, TypeSchemaCache, createLoggerFromConfig, TypeSchemaGenerator, TypeSchemaParser, TypeScriptAPIGenerator, APIBuilder, createAPI, generateTypesFromPackage, generateTypesFromFiles, DEFAULT_CONFIG, CONFIG_FILE_NAMES, ConfigValidator, ConfigLoader, configLoader, loadConfig, isConfig };
+export { __toESM, __commonJS, __require, TypeSchemaCache, createLoggerFromConfig, TypeSchemaGenerator, TypeSchemaParser, RestClientGenerator, TypeScriptAPIGenerator, APIBuilder, createAPI, createAPIFromConfig, generateTypesFromPackage, generateTypesFromFiles, DEFAULT_CONFIG, CONFIG_FILE_NAMES, ConfigValidator, ConfigLoader, configLoader, loadConfig, isConfig };