@atomic-ehr/codegen 0.0.4 → 0.0.5-canary.20251229160950.1f6114f

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Atomic EHR Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,26 +1,60 @@
-# Atomic FHIR Codegen
+# Atomic EHR Codegen
 
 [![npm canary](https://img.shields.io/npm/v/@atomic-ehr/codegen/canary.svg?label=canary)](https://www.npmjs.com/package/@atomic-ehr/codegen/v/canary)
 [![npm version](https://badge.fury.io/js/%40atomic-ehr%2Fcodegen.svg)](https://badge.fury.io/js/%40atomic-ehr%2Fcodegen)
 [![CI](https://github.com/atomic-ehr/codegen/actions/workflows/ci.yml/badge.svg)](https://github.com/atomic-ehr/codegen/actions/workflows/ci.yml)
 [![SDK Tests](https://github.com/atomic-ehr/codegen/actions/workflows/sdk-tests.yml/badge.svg)](https://github.com/atomic-ehr/codegen/actions/workflows/sdk-tests.yml)
 
-A powerful, extensible code generation toolkit for FHIR (Fast Healthcare Interoperability Resources) that transforms FHIR specifications into strongly-typed code for multiple programming languages.
+<!-- markdown-toc start - Don't edit this section. Run M-x markdown-toc-refresh-toc -->
+**Table of Contents**
+
+- [Atomic EHR Codegen](#atomic-ehr-codegen)
+  - [Features](#features)
+  - [Versions & Release Cycle](#versions--release-cycle)
+  - [Installation](#installation)
+  - [Quick Start](#quick-start)
+    - [Usage Examples](#usage-examples)
+  - [Architecture](#architecture)
+    - [Input - FHIR packages & resolves canonicals](#input---fhir-packages--resolves-canonicals)
+      - [Load Local StructureDefinitions & TGZ Archives](#load-local-structuredefinitions--tgz-archives)
+    - [Intermediate - Type Schema](#intermediate---type-schema)
+      - [Tree Shaking](#tree-shaking)
+        - [Field-Level Tree Shaking](#field-level-tree-shaking)
+    - [Generation](#generation)
+      - [1. Writer-Based Generation (Programmatic)](#1-writer-based-generation-programmatic)
+      - [2. Mustache Template-Based Generation (Declarative)](#2-mustache-template-based-generation-declarative)
+  - [Roadmap](#roadmap)
+  - [Support](#support)
+- [Footnotes](#footnotes)
+
+<!-- markdown-toc end -->
+
+A powerful, extensible code generation toolkit for FHIR ([Fast Healthcare Interoperability Resources](https://www.hl7.org/fhir/)) that transforms FHIR specifications into strongly-typed code for multiple programming languages.
+
+Guides:
+
+- **[Writer Generator Guide](docs/guides/writer-generator.md)** - Build custom code generators with the Writer base class
+- **[Mustache Generator Guide](docs/guides/mustache-generator.md)** - Template-based code generation for any language
+- **[TypeSchemaIndex Guide](docs/guides/typeschema-index.md)** - Type Schema structure and utilities
+- **[Testing Generators Guide](docs/guides/testing-generators.md)** - Unit tests, snapshot testing, and best practices
+- **[Contributing Guide](CONTRIBUTING.md)** - Development setup and workflow
 
 ## Features
 
 - 🚀 **High-Performance** - Built with Bun runtime for blazing-fast generation
-- 🔧 **Extensible Architecture** - Three-stage pipeline (Resolve Canonicals → Transform to Type Schema → Generate)
-- 📦 **Multi-Package Support** - Generate from a list of FHIR packages (profiles in development)
+- 🔧 **Extensible Architecture** - Three-stage pipeline:
+    - FHIR package management & canonical resolution
+    - Optimized intermediate FHIR data entities representation via Type Schema
+    - Generation for different programming languages
+- 📦 **Multi-Package Support** - Generate from a list of FHIR packages
 - 🎯 **Type-Safe** - Generates fully typed interfaces with proper inheritance
-- 🔄 **Intermediate Format** - TypeSchema format enables multi-language support
-- 🛠️  **Developer Friendly** - Fluent API, CLI, and configuration file support
+- 🛠️ **Developer Friendly** - Fluent API
 
-## Versions
+## Versions & Release Cycle
 
 - `canary` channel - Latest development version from `main` branch
-- `latest` channel - Latest stable version (currently in developer preview)
-- all versions: [NPM: @atomic-ehr/codegen](https://www.npmjs.com/package/@atomic-ehr/codegen?activeTab=versions)
+- `latest` channel - Latest stable version, changelog: [Releases](https://github.com/atomic-ehr/codegen/releases)
+- All versions: [NPM: @atomic-ehr/codegen](https://www.npmjs.com/package/@atomic-ehr/codegen?activeTab=versions)
 
 ## Installation
 
@@ -37,312 +71,200 @@ yarn add @atomic-ehr/codegen
 
 ## Quick Start
 
-### 1. Using the Fluent API (Primary)
+1. Write SDK generation script (`generate-types.ts`):
 
-```typescript
-import { APIBuilder } from '@atomic-ehr/codegen';
-
-const builder = new APIBuilder()
-    .fromPackage("hl7.fhir.r4.core", "4.0.1")
-    .typescript({})
-    .outputTo("./examples/typescript-r4/fhir-types");
-
-const report = await builder.generate();
-console.log(report);
-```
-
-Run the script with:
+    ```typescript
+    import { APIBuilder, prettyReport } from '@atomic-ehr/codegen';
 
-- `npm exec tsx scripts/generate-types.ts`
-- `pnpm exec tsx scripts/generate-types.ts`
-- `bun run scripts/generate-types.ts`
+    const builder = new APIBuilder()
+        .fromPackage("hl7.fhir.r4.core", "4.0.1")
+        .typescript({})
+        .outputTo("./examples/typescript-r4/fhir-types");
 
-### 2. Using the CLI (Draft)
+    const report = await builder.generate();
+    console.log(prettyReport(report));
+    ```
 
-```bash
-# Generate using configuration file
-bunx atomic-codegen generate
+2. Run the script with:
 
-# Generate with verbose output
-bunx atomic-codegen generate --verbose
+    - `npm exec tsx generate-types.ts`
+    - `bun run generate-types.ts`
+    - `pnpm exec tsx generate-types.ts`
 
-# Generate TypeSchemas from FHIR package
-bunx atomic-codegen typeschema generate hl7.fhir.r4.core@4.0.1 -o schemas.ndjson
-```
+### Usage Examples
 
-### 3. Using Configuration File (Draft)
+See the [examples/](examples/) directory for working demonstrations:
 
-Create `atomic-codegen.config.ts`:
+- **[typescript-r4/](examples/typescript-r4/)** - FHIR R4 type generation with resource creation demo and profile usage
+- **[typescript-ccda/](examples/typescript-ccda/)** - C-CDA on FHIR type generation
+- **[typescript-sql-on-fhir/](examples/typescript-sql-on-fhir/)** - SQL on FHIR ViewDefinition with tree shaking
+- **[python/](examples/python/)** - Python/Pydantic model generation with configurable field formats
+- **[csharp/](examples/csharp/)** - C# class generation with namespace configuration
+- **[mustache/](examples/mustache/)** - Java generation with Mustache templates and post-generation hooks
+- **[local-package-folder/](examples/local-package-folder/)** - Loading unpublished local FHIR packages
 
-```typescript
-import { defineConfig } from "@atomic-ehr/codegen";
-
-export default defineConfig({
-  outputDir: "./generated",
-  overwrite: true,
-  validate: true,
-  cache: true,
-  packages: ["hl7.fhir.r4.core@4.0.1"],
-  typescript: {
-    includeDocuments: true,
-    namingConvention: "PascalCase",
-    includeProfiles: false,
-    includeExtensions: false,
-    generateIndex: true,
-    strictMode: true,
-    generateValueSets: true,
-    includeValueSetHelpers: true,
-    valueSetStrengths: ["required", "preferred"],
-    valueSetMode: "custom"
-  }
-});
-```
-
-Then run:
-
-```bash
-bunx atomic-codegen generate
-```
+For detailed documentation, see [examples/README.md](examples/README.md).
 
 ## Architecture
 
 The toolkit uses a three-stage architecture (details: [link](https://www.health-samurai.io/articles/type-schema-a-pragmatic-approach-to-build-fhir-sdk)):
 
-```
-Resolve Canonicals → Transform to Type Schema → Generate
-```
-
-1. **Input Layer** - Parses FHIR packages and profiles, resolves canonicals, and transforms them into TypeSchema format
-2. **Intermediate Format** - TypeSchema provides a universal representation for FHIR data entities
-3. **Output Generators** - Generate code for TypeScript, Python, and other languages
-
-## Usage Examples
+1. **Input** - FHIR packages & resolves canonicals
+2. **Intermediate representation** - TypeSchema provides a universal representation for FHIR data entities and processing utilities
+3. **Generation** - Generate code for TypeScript, Python, etc.
 
-Actual examples of type generation and usage can be found here: [examples/typescript-r4](examples/typescript-r4):
-
-- `demo.ts` - a simple script that creates resources and demonstrates how to work with profiles
-- `generate.ts` - script to generate types
-
-### Generate Types for a Custom Profile (Draft)
+The `APIBuilder` provides a fluent interface for configuring and generating code:
 
 ```typescript
-import { APIBuilder } from '@atomic-ehr/codegen';
-
-const builder = new APIBuilder();
-
-// Load custom profile
-await builder
-  .fromProfile('./profiles/my-patient-profile.json')
-  .withBaseProfile('http://hl7.org/fhir/StructureDefinition/Patient')
-  .typescript({
-    outputDir: './generated/profiles',
-    includeValidators: true,
-  })
-  .generate();
+const builder = new APIBuilder()
+
+    // Input sources (choose one or combine)
+    .fromPackage("hl7.fhir.r4.core", "4.0.1") // NPM registry package
+    .fromPackageRef("https://...package.tgz")  // Remote TGZ file
+    .localStructureDefinitions({ ... })        // Loose JSON files
+
+    // Type Schema processing
+    .treeShake({ ... })                        // Include only specified types
+
+    // Code generator (choose one)
+    .typescript({                              // TypeScript generator
+        generateProfile?: boolean,
+        withDebugComment?: boolean,
+        openResourceTypeSet?: boolean,
+    })
+    .python({                                   // Python generator
+        allowExtraFields?: boolean,
+        fieldFormat?: "snake_case" | "camelCase",
+        staticDir?: string,
+    })
+    .csharp("NameSpace", "staticFilesPath")   // C# generator
+
+    // Output configuration
+    .outputTo("./generated/types")             // Output directory
+    .cleanOutput(true)                         // Clean before generation
+
+    // Optional: Optimization & debugging
+    .throwException()                          // Throw on errors (optional)
+    .writeTypeSchemas("./schemas")             // Export TypeSchema files
+    .writeTypeTree("./tree.yaml")              // Export dependency tree
+
+    // Execute generation
+    .generate();                                // Returns GenerationReport
 ```
 
-### Generate with Custom Templates (Draft)
+Each method returns the builder instance, allowing method chaining. The `generate()` method executes the pipeline and returns a report with success status and generated file details.
 
-```typescript
-import { APIBuilder } from '@atomic-ehr/codegen';
+### Input - FHIR packages & resolves canonicals
 
-const builder = new APIBuilder();
+The input stage leverages [Canonical Manager](https://github.com/atomic-ehr/canonical-manager) to handle FHIR package management and dependency resolution. It processes FHIR packages from multiple sources (registry, local files, TGZ archives) and resolves all canonical URLs to their concrete definitions, ensuring all references between resources are properly linked before transformation.
 
-await builder
-  .fromPackage('hl7.fhir.r4.core', '4.0.1')
-  .withTemplate('./templates/custom-interface.hbs')
-  .typescript({
-    outputDir: './generated',
-    customHelpers: {
-      upperCase: (str) => str.toUpperCase()
-    }
-  })
-  .generate();
-```
+The [`Register`](src/typeschema/register.ts) component wraps Canonical Manager specifically for codegen purposes, providing:
 
-### Generate Multiple Output Formats (Draft)
+- **Multi-package indexing** for fast canonical URL lookups across package boundaries
+- **Package-aware resolution** with automatic dependency tree traversal
+- **FHIR-to-TypeSchema conversion** using the `@atomic-ehr/fhirschema` translator
+- **Element snapshot generation** that merges inherited properties from base resources
 
-```typescript
-import { APIBuilder } from '@atomic-ehr/codegen';
-
-const builder = new APIBuilder();
-
-// Parse once, generate multiple formats
-const schemas = await builder
-  .fromPackage('hl7.fhir.r4.core', '4.0.1')
-  .parse();
-
-// Generate TypeScript
-await builder
-  .fromSchemas(schemas)
-  .typescript({ outputDir: './ts-types' })
-  .generate();
-
-// Generate Python (coming soon)
-await builder
-  .fromSchemas(schemas)
-  .python({ outputDir: './py-types' })
-  .generate();
-```
+#### Load Local StructureDefinitions & TGZ Archives
 
-## CLI Commands (Draft)
+Use the new `localPackage` helper to point the builder at an on-disk FHIR package folder (for example, an unpublished implementation guide). If you only have loose StructureDefinition JSON files, group them under a folder and pass it to `localStructureDefinitions`. Canonical Manager handles copying, indexing, and dependency installation in both scenarios, so the API builder only needs to describe where the files live and what upstream packages they depend on.
 
-```bash
-# Generate code using configuration file
-atomic-codegen generate                    # Uses atomic-codegen.config.ts
-atomic-codegen generate --verbose          # With detailed output
-atomic-codegen generate --config custom.ts # Custom config file
-
-# TypeSchema operations
-atomic-codegen typeschema generate hl7.fhir.r4.core@4.0.1 -o schemas.ndjson
-atomic-codegen typeschema validate schemas.ndjson
-
-# Help and debugging
-atomic-codegen --help                      # Show help
-atomic-codegen --debug generate            # Debug mode
+```typescript
+.localStructureDefinitions({
+    package: { name: "example.local.structures", version: "0.0.1" },
+    path: "./custom-profiles",
+    dependencies: [{ name: "hl7.fhir.r4.core", version: "4.0.1" }],
+})
+.localTgzPackage("./packages/my-custom-ig.tgz")
 ```
 
-## Configuration Options (Draft)
+The example above points Canonical Manager at `./custom-profiles`, installs the HL7 R4 core dependency automatically, and then limits generation to the custom `ExampleNotebook` logical model plus the standard R4 `Patient` resource via tree shaking. The `localTgzPackage` helper registers `.tgz` artifacts that Canonical Manager already knows how to unpack.
 
-### Global Configuration Options
+### Intermediate - Type Schema
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `outputDir` | `string` | `./generated` | Base output directory for all generated files |
-| `overwrite` | `boolean` | `false` | Overwrite existing files without prompting |
-| `validate` | `boolean` | `true` | Validate generated TypeSchema before processing |
-| `cache` | `boolean` | `true` | Enable caching for improved performance |
-| `packages` | `string[]` | `[]` | FHIR packages to process (e.g., `"hl7.fhir.r4.core@4.0.1"`) |
+Type Schema serves as a universal intermediate representation that bridges FHIR's complex hierarchical structure with programming language constructs. It transforms FHIR StructureDefinitions into a flattened, code-generation-friendly format that:
 
-### TypeScript Generator Options
+- **Unifies** all FHIR elements (Resources, Types, ValueSets) into a consistent structure
+- **Flattens** nested paths for direct field access without complex traversal
+- **Enriches** definitions with resolved references, value set expansions, and type dependencies
+- **Simplifies** FHIR concepts like choice types and extensions for easier code generation
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `outputDir` | `string` | `./generated` | Output directory for generated files |
-| `moduleFormat` | `'esm' \| 'cjs'` | `'esm'` | Module format |
-| `generateIndex` | `boolean` | `true` | Generate index file with exports |
-| `includeDocuments` | `boolean` | `true` | Include JSDoc documentation |
-| `namingConvention` | `'PascalCase' \| 'camelCase'` | `'PascalCase'` | Type naming convention |
-| `includeExtensions` | `boolean` | `false` | Include FHIR extensions |
-| `includeProfiles` | `boolean` | `false` | Include FHIR profiles |
-| `generateValueSets` | `boolean` | `false` | Generate strongly-typed value sets from FHIR bindings |
-| `valueSetStrengths` | `string[]` | `['required']` | Which binding strengths to generate |
-| `includeValueSetHelpers` | `boolean` | `false` | Include validation helper functions |
-| `valueSetDirectory` | `string` | `'valuesets'` | Output directory for value set files |
+This approach enables generating idiomatic code for any programming language while preserving FHIR semantics and constraints. Learn more: [Type Schema specification](https://www.health-samurai.io/articles/type-schema-a-pragmatic-approach-to-build-fhir-sdk).
 
-## Value Set Generation
+#### Tree Shaking
 
-Generate strongly-typed TypeScript enums from FHIR value sets for enhanced type safety:
+Tree shaking optimizes the generated output by including only the resources you explicitly need and their dependencies. Instead of generating types for an entire FHIR package (which can contain hundreds of resources), you can specify exactly which resources to include:
 
 ```typescript
-// Configuration
-export default defineConfig({
-  generators: {
-    typescript: {
-      generateValueSets: true,
-      valueSetStrengths: ['required', 'preferred'],
-      includeValueSetHelpers: true,
-    },
-  },
-});
+.treeShake({
+  "hl7.fhir.r4.core#4.0.1": {
+    "http://hl7.org/fhir/StructureDefinition/Patient": {},
+    "http://hl7.org/fhir/StructureDefinition/Observation": {},
+  }
+})
 ```
 
-### Value Set Configuration Options
-
-- **generateValueSets**: Enable value set generation
-- **valueSetStrengths**: Control which binding strengths generate types (`'required'`, `'preferred'`, `'extensible'`, `'example'`)
-- **includeValueSetHelpers**: Include runtime validation functions
-- **valueSetDirectory**: Customize output directory name
+This feature automatically resolves and includes all dependencies (referenced types, base resources, nested types) while excluding unused resources, significantly reducing the size of generated code and improving compilation times.
 
-For comprehensive usage examples and migration guides, see [Value Set Documentation](docs/features/value-set-generation.md).
+##### Field-Level Tree Shaking
 
-## Development
+Beyond resource-level filtering, tree shaking supports fine-grained field selection using `selectFields` (whitelist) or `ignoreFields` (blacklist):
 
-### Prerequisites
-
-- [Bun](https://bun.sh) runtime (v1.0+)
-- Node.js 18+ (for compatibility)
+```typescript
+.treeShake({
+  "hl7.fhir.r4.core#4.0.1": {
+    "http://hl7.org/fhir/StructureDefinition/Patient": {
+      selectFields: ["id", "name", "birthDate", "gender"]
+    },
+    "http://hl7.org/fhir/StructureDefinition/Observation": {
+      ignoreFields: ["performer", "note"]
+    }
+  }
+})
+```
 
-### Setup
+**Configuration Rules:**
+- `selectFields`: Only includes the specified fields (whitelist approach)
+- `ignoreFields`: Removes specified fields, keeps everything else (blacklist approach)
+- These options are **mutually exclusive** - you cannot use both in the same rule
 
-```bash
-# Clone repository
-git clone https://github.com/your-org/atomic-codegen
-cd atomic-codegen
+**Polymorphic Field Handling:**
 
-# Install dependencies
-bun install
+FHIR choice types (like `multipleBirth[x]` which can be boolean or integer) are handled intelligently. Selecting/ignoring the base field affects all variants, while targeting specific variants only affects those types.
 
-# Run tests
-bun test
+### Generation
 
-# Build
-bun run build
-```
+The generation stage transforms Type Schema into target language code using two complementary approaches:
 
-## Contributing
+#### 1. Writer-Based Generation (Programmatic)
 
-We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+For languages with built-in support (TypeScript, Python, C#), extend the `Writer` class to implement language-specific generators:
 
-## License
+- **FileSystemWriter**: Base class providing file I/O, directory management, and buffer handling (both disk and in-memory modes)
+- **Writer**: Extends FileSystemWriter with code formatting utilities (indentation, blocks, comments, line management)
+- **Language Writers** (`TypeScript`, `Python`[^py], `CSharp`): Implement language-specific generation logic by traversing TypeSchema index and generating corresponding types, interfaces, or classes
 
-MIT © Atomic Healthcare
+[^py]: For details on [Type Schema: Python SDK for FHIR](https://www.health-samurai.io/articles/type-schema-python-sdk-for-fhir)
 
-## Support
+Each language writer maintains full control over output formatting while leveraging high-level abstractions for common code patterns. Writers follow language idioms and best practices, with optimized output for production use.
 
-- 📖 [Documentation](https://docs.atomic-ehr.com/codegen)
-- 🐛 [Issue Tracker](https://github.com/atomic-ehr/codegen/issues)
+**When to use**: Full control needed, complex generation logic, performance-critical, language has a dedicated writer, production-grade output
 
-## Next Steps: REST Client & Advanced Features
+#### 2. Mustache Template-Based Generation (Declarative)
 
-We're expanding beyond type generation to create a complete FHIR development toolkit:
+For custom languages or formats, use Mustache templates to define code generation rules without programming:
 
-### 🔄 REST Client Generation (Q2 2024)
-```typescript
-// Generate type-safe FHIR clients
-await builder
-  .fromPackage('hl7.fhir.r4.core', '4.0.1')
-  .restClient({
-    clientName: 'MyFHIRClient',
-    baseUrl: 'https://api.example.com/fhir',
-    authType: 'oauth2'
-  })
-  .generate();
-
-// Use generated client
-const client = new MyFHIRClient();
-const patient = await client.Patient.read('123');
-const bundle = await client.Patient.search({ name: 'Smith' });
-```
+- **Template Files**: Declarative Mustache templates that describe output structure
+- **Configuration**: JSON config file controlling type filtering, naming, and post-generation hooks
+- **ViewModels**: Type Schema automatically transformed into template-friendly data structures
 
-### 🔍 Smart Chained Search (Q3 2024)
-```typescript
-// Intelligent search builders
-const results = await client.Patient
-  .search()
-  .name().contains('Smith')
-  .birthdate().greaterThan('2000-01-01')
-  .address().city().equals('Boston')
-  .include('Patient:organization')
-  .sort('birthdate', 'desc')
-  .execute();
-```
+Templates enable flexible code generation for any language or format (Go, Rust, GraphQL, documentation, configs) by describing the output format rather than implementing generation logic.
 
-### ⚡ Operation Generation (Q4 2024)
-```typescript
-// Type-safe FHIR operations
-const result = await client.Patient
-  .operation('$match')
-  .withParameters({
-    resource: patient,
-    onlyCertainMatches: true
-  })
-  .execute();
-```
+**When to use**: Custom language support, quick prototyping, template-driven customization, non-code output
 
-See our detailed [**ROADMAP.md**](ROADMAP.md) for the complete development plan.
+---
 
-## Current Roadmap
+## Roadmap
 
 - [x] TypeScript generation
 - [x] FHIR R4 core package support
@@ -351,17 +273,45 @@ See our detailed [**ROADMAP.md**](ROADMAP.md) for the complete development plan.
 - [x] **Value Set Generation** - Strongly-typed enums from FHIR bindings
 - [~] **Profile & Extension Support** - Basic parsing (US Core in development)
 - [ ] **Complete Multi-Package Support** - Custom packages and dependencies
-- [ ] **REST Client Generation** - Fetch-based FHIR clients
 - [ ] **Smart Chained Search** - Intelligent search builders
+
+    ```typescript
+    // Intelligent search builders
+    const results = await client.Patient
+        .search()
+        .name().contains('Smith')
+        .birthdate().greaterThan('2000-01-01')
+        .address().city().equals('Boston')
+        .include('Patient:organization')
+        .sort('birthdate', 'desc')
+        .execute();
+    ```
+
 - [ ] **Operation Generation** - Type-safe FHIR operations
-- [ ] **Python generation**
+
+    ```typescript
+    // Type-safe FHIR operations
+    const result = await client.Patient
+        .operation('$match')
+        .withParameters({
+            resource: patient,
+            onlyCertainMatches: true
+        })
+        .execute();
+    ```
+
+- [x] **Python generation**
+- [x] **C# generation**
 - [ ] **Rust generation**
 - [ ] **GraphQL schema generation**
 - [ ] **OpenAPI specification generation**
 - [ ] **Validation functions**
 - [ ] **Mock data generation**
-- [ ] **FHIR R5 support**
+
+## Support
+
+- 🐛 [Issue Tracker](https://github.com/atomic-ehr/codegen/issues)
 
 ---
 
-Built with ❤️  by the Atomic Healthcare team
+Built with ❤️ by the Atomic Healthcare team