@atomic-ehr/codegen 0.0.1-canary.20250924120719.44f2f7c → 0.0.1-canary.20250925150012.6169b6d

package/dist/typeschema/profile/processor.d.ts

@@ -5,10 +5,9 @@
  * This file is deprecated as profiles are not part of the core TypeSchema specification
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type { FHIRSchema } from "@atomic-ehr/fhirschema";
-import type { PackageInfo, TypeSchemaForProfile } from "../types.js";
+import type { TypeSchemaForProfile } from "../types";
 /**
  * Transform a FHIR profile to TypeSchema format
  * Profiles are treated as specialized resources that extend base resources
  */
-export declare function transformProfile(fhirSchema: FHIRSchema, manager: ReturnType<typeof CanonicalManager>, packageInfo?: PackageInfo): Promise<TypeSchemaForProfile>;
+export declare function transformProfile(fhirSchema: RichFHIRSchema, manager: ReturnType<typeof CanonicalManager>): Promise<TypeSchemaForProfile>;

package/dist/typeschema/profile/processor.js

@@ -5,15 +5,16 @@
  * Handles transformation of FHIR profiles to TypeSchema format
  * This file is deprecated as profiles are not part of the core TypeSchema specification
  */
-import { buildSchemaIdentifier } from "../core/identifier.js";
-import { transformElements } from "../core/transformer.js";
+import { buildSchemaIdentifier } from "../core/identifier";
+import { transformElements } from "../core/transformer";
 /**
  * Transform a FHIR profile to TypeSchema format
  * Profiles are treated as specialized resources that extend base resources
  */
-export async function transformProfile(fhirSchema, manager, packageInfo) {
+export async function transformProfile(fhirSchema, manager) {
     // Build profile identifier
-    const identifier = buildSchemaIdentifier(fhirSchema, packageInfo);
+    const identifier = buildSchemaIdentifier(fhirSchema);
+    const packageInfo = fhirSchema.package_meta;
     // Ensure this is recognized as a profile
     if (identifier.kind !== "profile") {
         throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);
@@ -33,10 +34,10 @@ export async function transformProfile(fhirSchema, manager, packageInfo) {
             kind: baseKind,
             package: isStandardFhir
                 ? "hl7.fhir.r4.core"
-                : packageInfo?.name || fhirSchema.package_name || "undefined",
+                : fhirSchema.package_meta.name || "undefined",
             version: isStandardFhir
                 ? "4.0.1"
-                : packageInfo?.version || fhirSchema.package_version || "undefined",
+                : fhirSchema.package_meta.version || "undefined",
             name: baseName,
             url: baseUrl,
         };
@@ -52,7 +53,7 @@ export async function transformProfile(fhirSchema, manager, packageInfo) {
         profileSchema.description = fhirSchema.description;
     }
     // Add profile-specific metadata
-    const metadata = extractProfileMetadata(fhirSchema, packageInfo);
+    const metadata = extractProfileMetadata(fhirSchema);
     if (Object.keys(metadata).length > 0) {
         profileSchema.metadata = metadata;
     }
@@ -117,8 +118,9 @@ async function determineBaseKind(baseUrl, manager) {
 /**
  * Extract profile metadata from FHIR schema
  */
-function extractProfileMetadata(fhirSchema, packageInfo) {
+function extractProfileMetadata(fhirSchema) {
     const metadata = {};
+    const packageInfo = fhirSchema.package_meta;
     // Add profile-specific metadata
     // @ts-ignore
     if (fhirSchema.publisher)
@@ -149,9 +151,9 @@ function extractProfileMetadata(fhirSchema, packageInfo) {
         metadata.package = packageInfo.name;
         // @ts-ignore
     }
-    else if (fhirSchema.package_name) {
+    else if (fhirSchema.package_meta.name) {
         // @ts-ignore
-        metadata.package = fhirSchema.package_name;
+        metadata.package = fhirSchema.package_meta.name;
     }
     return metadata;
 }

package/dist/typeschema/types.d.ts

@@ -1,482 +1,178 @@
 /**
- * A code generation friendly representation of FHIR StructureDefinition and FHIR Schema designed to simplify SDK resource classes/types generation.
+ * A code generation friendly representation of FHIR StructureDefinition and
+ * FHIR Schema designed to simplify SDK resource classes/types generation.
  */
-export type TypeSchemaIdentifierBase = {
+import type * as FS from "@atomic-ehr/fhirschema";
+export interface PackageInfo {
+    name: string;
+    version: string;
+}
+export type RichFHIRSchema = Omit<FS.FHIRSchema, "package_meta"> & {
+    package_meta: PackageInfo;
+};
+export declare const enrichFHIRSchema: (schema: FS.FHIRSchema) => RichFHIRSchema;
+type IdentifierBase = {
     name: string;
     package: string;
     version: string;
     url: string;
 };
-export type TypeSchema = TypeSchemaForPrimitiveType | TypeSchemaForResourceComplexTypeLogical | TypeSchemaForValueSet | TypeSchemaForBinding | TypeSchemaForProfile;
-export type TypeSchemaIdentifier = TypeSchemaIdentifierBase & (WithProfileKind | WithPrimitiveTypeKind | WithValuesetKind | WithComplexTypeKind | WithResourceKind | WithNestedKind | WithLogicalKind | WithBindingKind);
-/**
- * Schema for basic FHIR data types like string, boolean, decimal
- */
-export interface TypeSchemaForPrimitiveType {
-    /**
-     * The unique identifier for this primitive type
-     */
-    identifier: TypeSchemaIdentifier & WithPrimitiveTypeKind;
-    /**
-     * Human-readable description of the primitive type
-     */
-    description?: string;
-    /**
-     * The base type this primitive type extends (typically Element)
-     */
-    base: WithPrimitiveTypeKind | WithValuesetKind | WithComplexTypeKind | WithResourceKind | WithNestedKind | WithLogicalKind | WithBindingKind;
-    /**
-     * Other types that this primitive type depends on
-     */
-    dependencies?: TypeSchemaIdentifier[];
-}
-/**
- * Constraint helper to ensure the kind profile
- */
-export interface WithProfileKind {
-    kind: "profile";
-    [k: string]: unknown;
-}
-/**
- * Constraint helper to ensure the kind is primitive-type
- */
-export interface WithPrimitiveTypeKind {
+type PrimitiveIdentifier = {
     kind: "primitive-type";
-    [k: string]: unknown;
-}
-/**
- * Constraint helper to ensure the kind is value-set
- */
-export interface WithValuesetKind {
-    kind: "value-set";
-    [k: string]: unknown;
-}
-/**
- * Constraint helper to ensure the kind is complex-type
- */
-export interface WithComplexTypeKind {
+} & IdentifierBase;
+type ComplexTypeIdentifier = {
     kind: "complex-type";
-    [k: string]: unknown;
-}
-/**
- * Constraint helper to ensure the kind is resource
- */
-export interface WithResourceKind {
+} & IdentifierBase;
+type ResourceIdentifier = {
     kind: "resource";
-    [k: string]: unknown;
-}
-/**
- * Constraint helper to ensure the kind is nested
- */
-export interface WithNestedKind {
+} & IdentifierBase;
+type ValueSetIdentifier = {
+    kind: "value-set";
+} & IdentifierBase;
+type NestedIdentifier = {
     kind: "nested";
-    [k: string]: unknown;
-}
-/**
- * Constraint helper to ensure the kind is logical
- */
-export interface WithLogicalKind {
-    kind: "logical";
-    [k: string]: unknown;
-}
-/**
- * Constraint helper to ensure the kind is value-set
- */
-export interface WithBindingKind {
+} & IdentifierBase;
+type BindingIdentifier = {
     kind: "binding";
-    [k: string]: unknown;
+} & IdentifierBase;
+type ProfileIdentifier = {
+    kind: "profile";
+} & IdentifierBase;
+type LogicalIdentifier = {
+    kind: "logical";
+} & IdentifierBase;
+export type Identifier = PrimitiveIdentifier | ComplexTypeIdentifier | ResourceIdentifier | NestedIdentifier | BindingIdentifier | ValueSetIdentifier | ProfileIdentifier | LogicalIdentifier;
+export type TypeSchema = TypeSchemaForPrimitiveType | TypeSchemaForResourceComplexTypeLogical | TypeSchemaForValueSet | TypeSchemaForBinding | TypeSchemaForProfile;
+interface TypeSchemaForPrimitiveType {
+    identifier: PrimitiveIdentifier;
+    description?: string;
+    base: Identifier;
+    dependencies?: Identifier[];
 }
-export interface TypeSchemaForProfile {
-    identifier: TypeSchemaIdentifier & WithProfileKind;
-    /**
-     * The base resource or type this profile constrains
-     */
-    base: TypeSchemaIdentifier;
-    /**
-     * Human-readable description of the profile
-     */
+interface TypeSchemaForProfile {
+    identifier: ProfileIdentifier;
+    base: Identifier;
     description?: string;
-    /**
-     * Fields defined or constrained by this profile
-     */
     fields?: Record<string, TypeSchemaField>;
-    /**
-     * Profile-specific constraints on elements
-     */
     constraints?: Record<string, ProfileConstraint>;
-    /**
-     * Extensions used by this profile
-     */
     extensions?: ProfileExtension[];
-    /**
-     * Validation rules specific to this profile
-     */
     validation?: ValidationRule[];
-    /**
-     * Other types that this profile depends on
-     */
-    dependencies?: TypeSchemaIdentifier[];
-    /**
-     * Additional profile metadata
-     */
+    dependencies?: Identifier[];
     metadata?: ProfileMetadata;
-    /**
-     * Nested types if any
-     */
     nested?: any[];
 }
-/**
- * Profile constraint on a field
- */
-export interface ProfileConstraint {
-    /**
-     * Minimum cardinality
-     */
+interface ProfileConstraint {
     min?: number;
-    /**
-     * Maximum cardinality
-     */
     max?: string;
-    /**
-     * Must Support flag
-     */
     mustSupport?: boolean;
-    /**
-     * Fixed value constraint
-     */
     fixedValue?: any;
-    /**
-     * Pattern value constraint
-     */
     patternValue?: any;
-    /**
-     * Value set binding constraint
-     */
     binding?: {
         strength: "required" | "extensible" | "preferred" | "example";
         valueSet: string;
     };
-    /**
-     * Type constraints
-     */
     types?: Array<{
         code: string;
         profile?: string[];
         targetProfile?: string[];
     }>;
-    /**
-     * Slicing information
-     */
     slicing?: {
         discriminator: any[];
         rules: string;
         ordered?: boolean;
     };
 }
-/**
- * Profile extension information
- */
-export interface ProfileExtension {
-    /**
-     * Element path where extension applies
-     */
+interface ProfileExtension {
     path: string;
-    /**
-     * Extension profile URL
-     */
     profile: string | string[];
-    /**
-     * Minimum cardinality
-     */
     min?: number;
-    /**
-     * Maximum cardinality
-     */
     max?: string;
-    /**
-     * Must Support flag
-     */
     mustSupport?: boolean;
 }
-/**
- * Profile validation rule
- */
-export interface ValidationRule {
-    /**
-     * Element path this rule applies to
-     */
+interface ValidationRule {
     path: string;
-    /**
-     * Rule key/identifier
-     */
     key: string;
-    /**
-     * Severity level
-     */
     severity: "error" | "warning" | "information";
-    /**
-     * Human readable description
-     */
     human: string;
-    /**
-     * FHIRPath expression
-     */
     expression?: string;
 }
-/**
- * Profile metadata
- */
-export interface ProfileMetadata {
-    /**
-     * Publisher information
-     */
+interface ProfileMetadata {
     publisher?: string;
-    /**
-     * Contact information
-     */
     contact?: any[];
-    /**
-     * Copyright notice
-     */
     copyright?: string;
-    /**
-     * Purpose statement
-     */
     purpose?: string;
-    /**
-     * Experimental flag
-     */
     experimental?: boolean;
-    /**
-     * Publication date
-     */
     date?: string;
-    /**
-     * Jurisdiction
-     */
     jurisdiction?: any[];
-    /**
-     * Package information
-     */
     package?: string;
 }
-/**
- * Schema for FHIR resources, complex types, and logical types
- */
 export interface TypeSchemaForResourceComplexTypeLogical {
-    /**
-     * The unique identifier for this resource or type
-     */
-    identifier: TypeSchemaIdentifier & (WithResourceKind | WithComplexTypeKind | WithLogicalKind);
-    /**
-     * The base type this resource or type extends
-     */
-    base?: TypeSchemaIdentifierBase & (WithPrimitiveTypeKind | WithValuesetKind | WithComplexTypeKind | WithResourceKind | WithNestedKind | WithLogicalKind | WithBindingKind);
-    /**
-     * Human-readable description of the resource or type
-     */
+    identifier: ResourceIdentifier | ComplexTypeIdentifier | LogicalIdentifier;
+    base?: Identifier;
     description?: string;
-    /**
-     * The fields contained in this resource or type
-     */
     fields?: {
         [k: string]: RegularField | PolymorphicValueXFieldDeclaration | PolymorphicValueXFieldInstance;
     };
-    /**
-     * BackboneElement types nested within this resource or type
-     */
     nested?: {
-        /**
-         * The unique identifier for this nested type
-         */
-        identifier: TypeSchemaIdentifier & WithNestedKind;
-        /**
-         * The base type this nested type extends (typically BackboneElement)
-         */
-        base: WithPrimitiveTypeKind | WithValuesetKind | WithComplexTypeKind | WithResourceKind | WithNestedKind | WithLogicalKind | WithBindingKind;
-        /**
-         * The fields contained in this nested type
-         */
+        identifier: NestedIdentifier;
+        base: Identifier;
         fields?: {
             [k: string]: RegularField | PolymorphicValueXFieldDeclaration | PolymorphicValueXFieldInstance;
         };
     }[];
-    /**
-     * Other types that this resource or type depends on
-     */
-    dependencies?: TypeSchemaIdentifier[];
+    dependencies?: Identifier[];
 }
-/**
- * A standard field with a single type
- */
 export interface RegularField {
-    /**
-     * The data type of this field
-     */
-    type: TypeSchemaIdentifierBase & (WithPrimitiveTypeKind | WithValuesetKind | WithComplexTypeKind | WithResourceKind | WithNestedKind | WithLogicalKind | WithBindingKind);
-    /**
-     * Reference to other types that this field can point to
-     */
-    reference?: TypeSchemaIdentifier[];
-    /**
-     * Whether this field must be provided in valid instances
-     */
+    type: Identifier;
+    reference?: Identifier[];
     required?: boolean;
-    /**
-     * Whether this field is prohibited in valid instances
-     */
     excluded?: boolean;
-    /**
-     * Whether this field can contain multiple values (cardinality > 1)
-     */
     array?: boolean;
-    binding?: TypeSchemaIdentifier & WithBindingKind;
-    /**
-     * For code fields, the set of valid values when bound to a required value set
-     */
+    binding?: BindingIdentifier;
     enum?: string[];
-    /**
-     * Minimum limit of items for an array
-     */
     min?: number;
-    /**
-     * Maximum limit of items for an array
-     */
     max?: number;
 }
-/**
- * The base declaration for a FHIR choice type (e.g., value[x])
- */
 export interface PolymorphicValueXFieldDeclaration {
-    /**
-     * The names of all concrete type options for this choice field
-     */
     choices: string[];
-    /**
-     * Whether at least one choice must be provided
-     */
     required?: boolean;
-    /**
-     * Whether all choices are prohibited
-     */
     excluded?: boolean;
-    /**
-     * Whether the selected choice can contain multiple values
-     */
     array?: boolean;
-    /**
-     * Minimum limit of items for an array
-     */
     min?: number;
-    /**
-     * Maximum limit of items for an array
-     */
     max?: number;
 }
-/**
- * A specific type option for a FHIR choice type (e.g., valueString, valueInteger)
- */
 export interface PolymorphicValueXFieldInstance {
-    /**
-     * The name of the choice field this instance belongs to (e.g., 'value' for valueString)
-     */
     choiceOf: string;
-    /**
-     * The data type of this choice option
-     */
-    type: TypeSchemaIdentifierBase & (WithPrimitiveTypeKind | WithValuesetKind | WithComplexTypeKind | WithResourceKind | WithNestedKind | WithLogicalKind | WithBindingKind);
-    /**
-     * Whether this specific choice must be provided
-     */
+    type: Identifier;
     required?: boolean;
-    /**
-     * Whether this specific choice is prohibited
-     */
     excluded?: boolean;
-    /**
-     * Whether this choice can contain multiple values
-     */
     array?: boolean;
-    /**
-     * Reference to other types that this field can point to
-     */
-    reference?: TypeSchemaIdentifier[];
-    /**
-     * For coded choices, information about the value set binding
-     */
-    binding?: TypeSchemaIdentifier & WithBindingKind;
-    /**
-     * For code fields, the set of valid values when bound to a required value set
-     */
+    reference?: Identifier[];
+    binding?: BindingIdentifier;
     enum?: string[];
-    /**
-     * Minimum limit of items for an array
-     */
     min?: number;
-    /**
-     * Maximum limit of items for an array
-     */
     max?: number;
 }
-/**
- * Schema for FHIR value sets that define terminology bindings
- */
 export interface TypeSchemaForValueSet {
-    /**
-     * The unique identifier for this value set
-     */
-    identifier: TypeSchemaIdentifier & WithValuesetKind;
-    /**
-     * Human-readable description of the value set
-     */
+    identifier: ValueSetIdentifier;
     description?: string;
-    /**
-     * The list of coded concepts contained in this value set
-     */
     concept?: {
-        /**
-         * The code value
-         */
         code: string;
-        /**
-         * The human-readable display text for this code
-         */
         display?: string;
-        /**
-         * The code system URL that defines this code
-         */
         system?: string;
     }[];
-    /**
-     * Complex value set composition rules when the value set is defined as a composition of other value sets
-     */
     compose?: {
         [k: string]: unknown;
     };
 }
 export interface TypeSchemaForBinding {
-    /**
-     * The unique identifier for this value set
-     */
-    identifier: TypeSchemaIdentifier & WithBindingKind;
-    /**
-     * Human-readable description of the value set
-     */
+    identifier: BindingIdentifier;
     description?: string;
-    type?: TypeSchemaIdentifier;
-    /**
-     * The strength of the binding
-     */
+    type?: Identifier;
     strength?: string;
-    /**
-     * The enumeration of values for the binding
-     */
     enum?: string[];
-    valueset?: TypeSchemaIdentifier & WithValuesetKind;
-    /**
-     * Other types that this resource or type depends on
-     */
-    dependencies?: TypeSchemaIdentifier[];
+    valueset?: ValueSetIdentifier;
+    dependencies?: Identifier[];
 }
 export type TypeSchemaField = RegularField | PolymorphicValueXFieldDeclaration | PolymorphicValueXFieldInstance;
 export interface TypeschemaGeneratorOptions {
@@ -484,12 +180,5 @@ export interface TypeschemaGeneratorOptions {
     logger?: import("../utils/codegen-logger").CodegenLogger;
     treeshake?: string[];
 }
-export interface PackageInfo {
-    name: string;
-    version: string;
-}
-export type TypeschemaParserOptions = {
-    format?: "auto" | "ndjson" | "json";
-    validate?: boolean;
-    strict?: boolean;
-};
+export declare function isBindingSchema(schema: TypeSchema): schema is TypeSchemaForBinding;
+export {};

package/dist/typeschema/types.js

@@ -1,4 +1,16 @@
 /**
- * A code generation friendly representation of FHIR StructureDefinition and FHIR Schema designed to simplify SDK resource classes/types generation.
+ * A code generation friendly representation of FHIR StructureDefinition and
+ * FHIR Schema designed to simplify SDK resource classes/types generation.
  */
-export {};
+export const enrichFHIRSchema = (schema) => {
+    return {
+        ...schema,
+        package_meta: {
+            name: schema.package_name || schema.package_meta.name || "undefined",
+            version: schema.package_version || schema.package_meta.version || "undefined",
+        },
+    };
+};
+export function isBindingSchema(schema) {
+    return schema.identifier.kind === "binding";
+}

package/dist/typeschema/value-set/processor.d.ts

@@ -4,7 +4,7 @@
  * Functions for transforming FHIR ValueSets into TypeSchema format
  */
 import type { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import type { PackageInfo, TypeSchemaForValueSet } from "../types.js";
+import type { PackageInfo, TypeSchemaForValueSet } from "../types";
 /**
  * Extract all concepts from a ValueSet
  */

package/dist/typeschema/value-set/processor.js

@@ -3,7 +3,7 @@
  *
  * Functions for transforming FHIR ValueSets into TypeSchema format
  */
-import { buildValueSetIdentifier } from "../core/identifier.js";
+import { buildValueSetIdentifier } from "../core/identifier";
 /**
  * Extract concepts from a CodeSystem
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomic-ehr/codegen",
-  "version": "0.0.1-canary.20250924120719.44f2f7c",
+  "version": "0.0.1-canary.20250925150012.6169b6d",
   "description": "Code generation tools for FHIR resources and TypeSchema definitions",
   "keywords": [
     "fhir",