@atomic-ehr/codegen 0.0.5 → 0.0.6

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import * as FS from '@atomic-ehr/fhirschema';
+import { FHIRSchema, StructureDefinition as StructureDefinition$1, FHIRSchemaElement } from '@atomic-ehr/fhirschema';
 import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
 
 /**
@@ -84,11 +86,44 @@ declare class CodegenLogger {
     setLevel(level: LogLevel): void;
 }
 
+interface Extension extends Element {
+    url: string;
+    valueCode?: string;
+    valueUri?: string;
+}
+
 interface Element {
+    extension?: Extension[];
     id?: string;
 }
 
-interface BackboneElement extends Element {
+interface Period extends Element {
+    end?: string;
+    start?: string;
+}
+
+interface Address extends Element {
+    city?: string;
+    country?: string;
+    district?: string;
+    line?: string[];
+    period?: Period;
+    postalCode?: string;
+    state?: string;
+    text?: string;
+    type?: ("postal" | "physical" | "both");
+    use?: ("home" | "work" | "temp" | "old" | "billing");
+}
+
+interface Quantity extends Element {
+    code?: string;
+    comparator?: ("<" | "<=" | ">=" | ">");
+    system?: string;
+    unit?: string;
+    value?: number;
+}
+
+interface Age extends Quantity {
 }
 
 interface Coding extends Element {
@@ -99,6 +134,546 @@ interface Coding extends Element {
     version?: string;
 }
 
+interface CodeableConcept extends Element {
+    coding?: Coding[];
+    text?: string;
+}
+
+interface Identifier extends Element {
+    assigner?: Reference<"Organization">;
+    period?: Period;
+    system?: string;
+    type?: CodeableConcept;
+    use?: ("usual" | "official" | "temp" | "secondary" | "old");
+    value?: string;
+}
+
+interface Reference<T extends string = string> extends Element {
+    display?: string;
+    identifier?: Identifier;
+    reference?: `${T}/${string}`;
+    type?: string;
+}
+
+interface Annotation extends Element {
+    authorReference?: Reference<"Organization" | "Patient" | "Practitioner" | "RelatedPerson">;
+    authorString?: string;
+    text: string;
+    time?: string;
+}
+
+interface Attachment extends Element {
+    contentType?: string;
+    creation?: string;
+    data?: string;
+    hash?: string;
+    language?: string;
+    size?: number;
+    title?: string;
+    url?: string;
+}
+
+interface BackboneElement extends Element {
+    modifierExtension?: Extension[];
+}
+
+interface ContactPoint extends Element {
+    period?: Period;
+    rank?: number;
+    system?: ("phone" | "fax" | "email" | "pager" | "url" | "sms" | "other");
+    use?: ("home" | "work" | "temp" | "old" | "mobile");
+    value?: string;
+}
+
+interface ContactDetail extends Element {
+    name?: string;
+    telecom?: ContactPoint[];
+}
+
+interface Narrative extends Element {
+    div: string;
+    status: ("generated" | "extensions" | "additional" | "empty");
+}
+
+interface Meta extends Element {
+    lastUpdated?: string;
+    profile?: string[];
+    security?: Coding[];
+    source?: string;
+    tag?: Coding[];
+    versionId?: string;
+}
+
+interface Resource {
+    resourceType: "CodeSystem" | "DomainResource" | "Resource" | "StructureDefinition" | "ValueSet";
+    id?: string;
+    implicitRules?: string;
+    language?: string;
+    meta?: Meta;
+}
+
+interface DomainResource extends Resource {
+    resourceType: "CodeSystem" | "DomainResource" | "StructureDefinition" | "ValueSet";
+    contained?: Resource[];
+    extension?: Extension[];
+    modifierExtension?: Extension[];
+    text?: Narrative;
+}
+
+interface Range extends Element {
+    high?: Quantity;
+    low?: Quantity;
+}
+
+interface UsageContext extends Element {
+    code: Coding;
+    valueCodeableConcept?: CodeableConcept;
+    valueQuantity?: Quantity;
+    valueRange?: Range;
+    valueReference?: Reference<"Group" | "HealthcareService" | "InsurancePlan" | "Location" | "Organization" | "PlanDefinition" | "ResearchStudy">;
+}
+
+interface CodeSystemConcept extends BackboneElement {
+    code: string;
+    concept?: CodeSystemConcept[];
+    definition?: string;
+    designation?: CodeSystemConceptDesignation[];
+    display?: string;
+    property?: CodeSystemConceptProperty[];
+}
+interface CodeSystemConceptDesignation extends BackboneElement {
+    language?: string;
+    use?: Coding;
+    value: string;
+}
+interface CodeSystemConceptProperty extends BackboneElement {
+    code: string;
+    valueBoolean?: boolean;
+    valueCode?: string;
+    valueCoding?: Coding;
+    valueDateTime?: string;
+    valueDecimal?: number;
+    valueInteger?: number;
+    valueString?: string;
+}
+interface CodeSystemFilter extends BackboneElement {
+    code: string;
+    description?: string;
+    operator: ("=" | "is-a" | "descendent-of" | "is-not-a" | "regex" | "in" | "not-in" | "generalizes" | "exists")[];
+    value: string;
+}
+interface CodeSystemProperty extends BackboneElement {
+    code: string;
+    description?: string;
+    type: ("code" | "Coding" | "string" | "integer" | "boolean" | "dateTime" | "decimal");
+    uri?: string;
+}
+interface CodeSystem extends DomainResource {
+    resourceType: "CodeSystem";
+    caseSensitive?: boolean;
+    compositional?: boolean;
+    concept?: CodeSystemConcept[];
+    contact?: ContactDetail[];
+    content: ("not-present" | "example" | "fragment" | "complete" | "supplement");
+    copyright?: string;
+    count?: number;
+    date?: string;
+    description?: string;
+    experimental?: boolean;
+    filter?: CodeSystemFilter[];
+    hierarchyMeaning?: ("grouped-by" | "is-a" | "part-of" | "classified-with");
+    identifier?: Identifier[];
+    jurisdiction?: CodeableConcept[];
+    name?: string;
+    property?: CodeSystemProperty[];
+    publisher?: string;
+    purpose?: string;
+    status: ("draft" | "active" | "retired" | "unknown");
+    supplements?: string;
+    title?: string;
+    url?: string;
+    useContext?: UsageContext[];
+    valueSet?: string;
+    version?: string;
+    versionNeeded?: boolean;
+}
+
+interface Contributor extends Element {
+    contact?: ContactDetail[];
+    name: string;
+    type: ("author" | "editor" | "reviewer" | "endorser");
+}
+
+interface Count extends Quantity {
+}
+
+interface Duration extends Quantity {
+}
+
+interface DataRequirement extends Element {
+    codeFilter?: Element[];
+    dateFilter?: Element[];
+    limit?: number;
+    mustSupport?: string[];
+    profile?: string[];
+    sort?: Element[];
+    subjectCodeableConcept?: CodeableConcept;
+    subjectReference?: Reference<"Group">;
+    type: string;
+}
+
+interface Distance extends Quantity {
+}
+
+interface Ratio extends Element {
+    denominator?: Quantity;
+    numerator?: Quantity;
+}
+
+interface Timing extends BackboneElement {
+    code?: CodeableConcept;
+    event?: string[];
+    repeat?: Element;
+}
+
+interface Dosage extends BackboneElement {
+    additionalInstruction?: CodeableConcept[];
+    asNeededBoolean?: boolean;
+    asNeededCodeableConcept?: CodeableConcept;
+    doseAndRate?: Element[];
+    maxDosePerAdministration?: Quantity;
+    maxDosePerLifetime?: Quantity;
+    maxDosePerPeriod?: Ratio;
+    method?: CodeableConcept;
+    patientInstruction?: string;
+    route?: CodeableConcept;
+    sequence?: number;
+    site?: CodeableConcept;
+    text?: string;
+    timing?: Timing;
+}
+
+interface Expression extends Element {
+    description?: string;
+    expression?: string;
+    language: string;
+    name?: string;
+    reference?: string;
+}
+
+interface HumanName extends Element {
+    family?: string;
+    given?: string[];
+    period?: Period;
+    prefix?: string[];
+    suffix?: string[];
+    text?: string;
+    use?: ("usual" | "official" | "temp" | "nickname" | "anonymous" | "old" | "maiden");
+}
+
+interface Money extends Element {
+    currency?: string;
+    value?: number;
+}
+
+interface ParameterDefinition extends Element {
+    documentation?: string;
+    max?: string;
+    min?: number;
+    name?: string;
+    profile?: string;
+    type: string;
+    use: ("in" | "out");
+}
+
+interface RelatedArtifact extends Element {
+    citation?: string;
+    display?: string;
+    document?: Attachment;
+    label?: string;
+    resource?: string;
+    type: ("documentation" | "justification" | "citation" | "predecessor" | "successor" | "derived-from" | "depends-on" | "composed-of");
+    url?: string;
+}
+
+interface SampledData extends Element {
+    data?: string;
+    dimensions: number;
+    factor?: number;
+    lowerLimit?: number;
+    origin: Quantity;
+    period: number;
+    upperLimit?: number;
+}
+
+interface Signature extends Element {
+    data?: string;
+    onBehalfOf?: Reference<"Device" | "Organization" | "Patient" | "Practitioner" | "PractitionerRole" | "RelatedPerson">;
+    sigFormat?: string;
+    targetFormat?: string;
+    type: Coding[];
+    when: string;
+    who: Reference<"Device" | "Organization" | "Patient" | "Practitioner" | "PractitionerRole" | "RelatedPerson">;
+}
+
+interface TriggerDefinition extends Element {
+    condition?: Expression;
+    data?: DataRequirement[];
+    name?: string;
+    timingDate?: string;
+    timingDateTime?: string;
+    timingReference?: Reference<"Schedule">;
+    timingTiming?: Timing;
+    type: ("named-event" | "periodic" | "data-changed" | "data-added" | "data-modified" | "data-removed" | "data-accessed" | "data-access-ended");
+}
+
+interface ElementDefinition extends BackboneElement {
+    alias?: string[];
+    base?: Element;
+    binding?: Element;
+    code?: Coding[];
+    comment?: string;
+    condition?: string[];
+    constraint?: Element[];
+    contentReference?: string;
+    defaultValueAddress?: Address;
+    defaultValueAge?: Age;
+    defaultValueAnnotation?: Annotation;
+    defaultValueAttachment?: Attachment;
+    defaultValueBase64Binary?: string;
+    defaultValueBoolean?: boolean;
+    defaultValueCanonical?: string;
+    defaultValueCode?: string;
+    defaultValueCodeableConcept?: CodeableConcept;
+    defaultValueCoding?: Coding;
+    defaultValueContactDetail?: ContactDetail;
+    defaultValueContactPoint?: ContactPoint;
+    defaultValueContributor?: Contributor;
+    defaultValueCount?: Count;
+    defaultValueDataRequirement?: DataRequirement;
+    defaultValueDate?: string;
+    defaultValueDateTime?: string;
+    defaultValueDecimal?: number;
+    defaultValueDistance?: Distance;
+    defaultValueDosage?: Dosage;
+    defaultValueDuration?: Duration;
+    defaultValueExpression?: Expression;
+    defaultValueHumanName?: HumanName;
+    defaultValueId?: string;
+    defaultValueIdentifier?: Identifier;
+    defaultValueInstant?: string;
+    defaultValueInteger?: number;
+    defaultValueMarkdown?: string;
+    defaultValueMeta?: Meta;
+    defaultValueMoney?: Money;
+    defaultValueOid?: string;
+    defaultValueParameterDefinition?: ParameterDefinition;
+    defaultValuePeriod?: Period;
+    defaultValuePositiveInt?: number;
+    defaultValueQuantity?: Quantity;
+    defaultValueRange?: Range;
+    defaultValueRatio?: Ratio;
+    defaultValueReference?: Reference;
+    defaultValueRelatedArtifact?: RelatedArtifact;
+    defaultValueSampledData?: SampledData;
+    defaultValueSignature?: Signature;
+    defaultValueString?: string;
+    defaultValueTime?: string;
+    defaultValueTiming?: Timing;
+    defaultValueTriggerDefinition?: TriggerDefinition;
+    defaultValueUnsignedInt?: number;
+    defaultValueUri?: string;
+    defaultValueUrl?: string;
+    defaultValueUsageContext?: UsageContext;
+    defaultValueUuid?: string;
+    definition?: string;
+    example?: Element[];
+    fixedAddress?: Address;
+    fixedAge?: Age;
+    fixedAnnotation?: Annotation;
+    fixedAttachment?: Attachment;
+    fixedBase64Binary?: string;
+    fixedBoolean?: boolean;
+    fixedCanonical?: string;
+    fixedCode?: string;
+    fixedCodeableConcept?: CodeableConcept;
+    fixedCoding?: Coding;
+    fixedContactDetail?: ContactDetail;
+    fixedContactPoint?: ContactPoint;
+    fixedContributor?: Contributor;
+    fixedCount?: Count;
+    fixedDataRequirement?: DataRequirement;
+    fixedDate?: string;
+    fixedDateTime?: string;
+    fixedDecimal?: number;
+    fixedDistance?: Distance;
+    fixedDosage?: Dosage;
+    fixedDuration?: Duration;
+    fixedExpression?: Expression;
+    fixedHumanName?: HumanName;
+    fixedId?: string;
+    fixedIdentifier?: Identifier;
+    fixedInstant?: string;
+    fixedInteger?: number;
+    fixedMarkdown?: string;
+    fixedMeta?: Meta;
+    fixedMoney?: Money;
+    fixedOid?: string;
+    fixedParameterDefinition?: ParameterDefinition;
+    fixedPeriod?: Period;
+    fixedPositiveInt?: number;
+    fixedQuantity?: Quantity;
+    fixedRange?: Range;
+    fixedRatio?: Ratio;
+    fixedReference?: Reference;
+    fixedRelatedArtifact?: RelatedArtifact;
+    fixedSampledData?: SampledData;
+    fixedSignature?: Signature;
+    fixedString?: string;
+    fixedTime?: string;
+    fixedTiming?: Timing;
+    fixedTriggerDefinition?: TriggerDefinition;
+    fixedUnsignedInt?: number;
+    fixedUri?: string;
+    fixedUrl?: string;
+    fixedUsageContext?: UsageContext;
+    fixedUuid?: string;
+    isModifier?: boolean;
+    isModifierReason?: string;
+    isSummary?: boolean;
+    label?: string;
+    mapping?: Element[];
+    max?: string;
+    maxLength?: number;
+    maxValueDate?: string;
+    maxValueDateTime?: string;
+    maxValueDecimal?: number;
+    maxValueInstant?: string;
+    maxValueInteger?: number;
+    maxValuePositiveInt?: number;
+    maxValueQuantity?: Quantity;
+    maxValueTime?: string;
+    maxValueUnsignedInt?: number;
+    meaningWhenMissing?: string;
+    min?: number;
+    minValueDate?: string;
+    minValueDateTime?: string;
+    minValueDecimal?: number;
+    minValueInstant?: string;
+    minValueInteger?: number;
+    minValuePositiveInt?: number;
+    minValueQuantity?: Quantity;
+    minValueTime?: string;
+    minValueUnsignedInt?: number;
+    mustSupport?: boolean;
+    orderMeaning?: string;
+    path: string;
+    patternAddress?: Address;
+    patternAge?: Age;
+    patternAnnotation?: Annotation;
+    patternAttachment?: Attachment;
+    patternBase64Binary?: string;
+    patternBoolean?: boolean;
+    patternCanonical?: string;
+    patternCode?: string;
+    patternCodeableConcept?: CodeableConcept;
+    patternCoding?: Coding;
+    patternContactDetail?: ContactDetail;
+    patternContactPoint?: ContactPoint;
+    patternContributor?: Contributor;
+    patternCount?: Count;
+    patternDataRequirement?: DataRequirement;
+    patternDate?: string;
+    patternDateTime?: string;
+    patternDecimal?: number;
+    patternDistance?: Distance;
+    patternDosage?: Dosage;
+    patternDuration?: Duration;
+    patternExpression?: Expression;
+    patternHumanName?: HumanName;
+    patternId?: string;
+    patternIdentifier?: Identifier;
+    patternInstant?: string;
+    patternInteger?: number;
+    patternMarkdown?: string;
+    patternMeta?: Meta;
+    patternMoney?: Money;
+    patternOid?: string;
+    patternParameterDefinition?: ParameterDefinition;
+    patternPeriod?: Period;
+    patternPositiveInt?: number;
+    patternQuantity?: Quantity;
+    patternRange?: Range;
+    patternRatio?: Ratio;
+    patternReference?: Reference;
+    patternRelatedArtifact?: RelatedArtifact;
+    patternSampledData?: SampledData;
+    patternSignature?: Signature;
+    patternString?: string;
+    patternTime?: string;
+    patternTiming?: Timing;
+    patternTriggerDefinition?: TriggerDefinition;
+    patternUnsignedInt?: number;
+    patternUri?: string;
+    patternUrl?: string;
+    patternUsageContext?: UsageContext;
+    patternUuid?: string;
+    representation?: ("xmlAttr" | "xmlText" | "typeAttr" | "cdaText" | "xhtml")[];
+    requirements?: string;
+    short?: string;
+    sliceIsConstraining?: boolean;
+    sliceName?: string;
+    slicing?: Element;
+    type?: Element[];
+}
+
+interface StructureDefinitionContext extends BackboneElement {
+    expression: string;
+    type: ("fhirpath" | "element" | "extension");
+}
+interface StructureDefinitionDifferential extends BackboneElement {
+    element: ElementDefinition[];
+}
+interface StructureDefinitionMapping extends BackboneElement {
+    comment?: string;
+    identity: string;
+    name?: string;
+    uri?: string;
+}
+interface StructureDefinitionSnapshot extends BackboneElement {
+    element: ElementDefinition[];
+}
+interface StructureDefinition extends DomainResource {
+    resourceType: "StructureDefinition";
+    abstract: boolean;
+    baseDefinition?: string;
+    contact?: ContactDetail[];
+    context?: StructureDefinitionContext[];
+    contextInvariant?: string[];
+    copyright?: string;
+    date?: string;
+    derivation?: ("specialization" | "constraint");
+    description?: string;
+    differential?: StructureDefinitionDifferential;
+    experimental?: boolean;
+    fhirVersion?: ("0.01" | "0.05" | "0.06" | "0.11" | "0.0.80" | "0.0.81" | "0.0.82" | "0.4.0" | "0.5.0" | "1.0.0" | "1.0.1" | "1.0.2" | "1.1.0" | "1.4.0" | "1.6.0" | "1.8.0" | "3.0.0" | "3.0.1" | "3.3.0" | "3.5.0" | "4.0.0" | "4.0.1");
+    identifier?: Identifier[];
+    jurisdiction?: CodeableConcept[];
+    keyword?: Coding[];
+    kind: ("primitive-type" | "complex-type" | "resource" | "logical");
+    mapping?: StructureDefinitionMapping[];
+    name: string;
+    publisher?: string;
+    purpose?: string;
+    snapshot?: StructureDefinitionSnapshot;
+    status: ("draft" | "active" | "retired" | "unknown");
+    title?: string;
+    type: string;
+    url: string;
+    useContext?: UsageContext[];
+    version?: string;
+}
+
 interface ValueSetCompose extends BackboneElement {
     exclude?: ValueSetComposeInclude[];
     inactive?: boolean;
@@ -127,6 +702,55 @@ interface ValueSetComposeIncludeFilter extends BackboneElement {
     property: string;
     value: string;
 }
+interface ValueSetExpansion extends BackboneElement {
+    contains?: ValueSetExpansionContains[];
+    identifier?: string;
+    offset?: number;
+    parameter?: ValueSetExpansionParameter[];
+    timestamp: string;
+    total?: number;
+}
+interface ValueSetExpansionContains extends BackboneElement {
+    abstract?: boolean;
+    code?: string;
+    contains?: ValueSetExpansionContains[];
+    designation?: ValueSetComposeIncludeConceptDesignation[];
+    display?: string;
+    inactive?: boolean;
+    system?: string;
+    version?: string;
+}
+interface ValueSetExpansionParameter extends BackboneElement {
+    name: string;
+    valueBoolean?: boolean;
+    valueCode?: string;
+    valueDateTime?: string;
+    valueDecimal?: number;
+    valueInteger?: number;
+    valueString?: string;
+    valueUri?: string;
+}
+interface ValueSet extends DomainResource {
+    resourceType: "ValueSet";
+    compose?: ValueSetCompose;
+    contact?: ContactDetail[];
+    copyright?: string;
+    date?: string;
+    description?: string;
+    expansion?: ValueSetExpansion;
+    experimental?: boolean;
+    identifier?: Identifier[];
+    immutable?: boolean;
+    jurisdiction?: CodeableConcept[];
+    name?: string;
+    publisher?: string;
+    purpose?: string;
+    status: ("draft" | "active" | "retired" | "unknown");
+    title?: string;
+    url?: string;
+    useContext?: UsageContext[];
+    version?: string;
+}
 
 type Name = string & {
     readonly __brand: unique symbol;
@@ -134,172 +758,78 @@ type Name = string & {
 type CanonicalUrl = string & {
     readonly __brand: unique symbol;
 };
+type PkgName$1 = string;
+type PkgVersion = string;
 interface PackageMeta {
-    name: string;
-    version: string;
+    name: PkgName$1;
+    version: PkgVersion;
 }
-type IdentifierBase = {
+type RichStructureDefinition = Omit<StructureDefinition, "url"> & {
+    package_name: PkgName$1;
+    package_version: PkgVersion;
+    url: CanonicalUrl;
+};
+type RichFHIRSchema = Omit<FS.FHIRSchema, "package_meta" | "base" | "name" | "url"> & {
+    package_meta: PackageMeta;
     name: Name;
     url: CanonicalUrl;
-    package: string;
-    version: string;
+    base: CanonicalUrl;
 };
-type PrimitiveIdentifier = {
-    kind: "primitive-type";
-} & IdentifierBase;
-type ComplexTypeIdentifier = {
-    kind: "complex-type";
-} & IdentifierBase;
-type ResourceIdentifier = {
-    kind: "resource";
-} & IdentifierBase;
-type ValueSetIdentifier = {
-    kind: "value-set";
-} & IdentifierBase;
-type NestedIdentifier = {
-    kind: "nested";
-} & IdentifierBase;
-type BindingIdentifier = {
-    kind: "binding";
-} & IdentifierBase;
-type ProfileIdentifier = {
-    kind: "profile";
-} & IdentifierBase;
-type LogicalIdentifier = {
-    kind: "logical";
-} & IdentifierBase;
-type Identifier = PrimitiveIdentifier | ComplexTypeIdentifier | ResourceIdentifier | NestedIdentifier | BindingIdentifier | ValueSetIdentifier | ProfileIdentifier | LogicalIdentifier;
-type TypeSchema = RegularTypeSchema | PrimitiveTypeSchema | ValueSetTypeSchema | BindingTypeSchema | ProfileTypeSchema;
-interface PrimitiveTypeSchema {
-    identifier: PrimitiveIdentifier;
-    description?: string;
-    base: Identifier;
-    dependencies?: Identifier[];
-}
-interface NestedType {
-    identifier: NestedIdentifier;
-    base: Identifier;
-    fields: Record<string, Field>;
-}
-interface ProfileTypeSchema {
-    identifier: ProfileIdentifier;
-    base: Identifier;
-    description?: string;
-    fields?: Record<string, Field>;
-    constraints?: Record<string, ProfileConstraint>;
-    extensions?: ProfileExtension[];
-    validation?: ValidationRule[];
-    dependencies?: Identifier[];
-    metadata?: ProfileMetadata;
-    nested?: NestedType[];
-}
-interface ProfileConstraint {
-    min?: number;
-    max?: string;
-    mustSupport?: boolean;
-    fixedValue?: any;
-    patternValue?: any;
-    binding?: {
-        strength: "required" | "extensible" | "preferred" | "example";
-        valueSet: string;
-    };
-    types?: Array<{
-        code: string;
-        profile?: string[];
-        targetProfile?: string[];
-    }>;
-    slicing?: {
-        discriminator: any[];
-        rules: string;
-        ordered?: boolean;
-    };
-}
-interface ProfileExtension {
-    path: string;
-    profile: string | string[];
-    min?: number;
-    max?: string;
-    mustSupport?: boolean;
-}
-interface ValidationRule {
-    path: string;
-    key: string;
-    severity: "error" | "warning" | "information";
-    human: string;
-    expression?: string;
-}
-interface ProfileMetadata {
-    publisher?: string;
-    contact?: any[];
-    copyright?: string;
-    purpose?: string;
-    experimental?: boolean;
-    date?: string;
-    jurisdiction?: any[];
-    package?: string;
-}
-interface RegularTypeSchema {
-    identifier: Identifier;
-    base?: Identifier;
-    description?: string;
-    fields?: {
-        [k: string]: Field;
-    };
-    nested?: NestedType[];
-    dependencies?: Identifier[];
-}
-interface RegularField {
-    type: Identifier;
-    reference?: Identifier[];
-    required?: boolean;
-    excluded?: boolean;
-    array?: boolean;
-    binding?: BindingIdentifier;
-    enum?: string[];
-    min?: number;
-    max?: number;
-}
-interface ChoiceFieldDeclaration {
-    choices: string[];
-    required?: boolean;
-    excluded?: boolean;
-    array?: boolean;
-    min?: number;
-    max?: number;
-}
-interface ChoiceFieldInstance {
-    choiceOf: string;
-    type: Identifier;
-    required?: boolean;
-    excluded?: boolean;
-    array?: boolean;
-    reference?: Identifier[];
-    binding?: BindingIdentifier;
-    enum?: string[];
-    min?: number;
-    max?: number;
-}
-type Concept = {
-    code: string;
-    display?: string;
-    system?: string;
+type RichValueSet = Omit<ValueSet, "name" | "url"> & {
+    package_meta: PackageMeta;
+    name: Name;
+    url: CanonicalUrl;
+};
+
+type IrConf = {
+    treeShake?: TreeShakeConf;
+    promoteLogical?: LogicalPromotionConf;
+};
+type LogicalPromotionConf = Record<PkgName$1, CanonicalUrl[]>;
+type TreeShakeConf = Record<string, Record<string, TreeShakeRule>>;
+type TreeShakeRule = {
+    ignoreFields?: string[];
+    selectFields?: string[];
 };
-interface ValueSetTypeSchema {
-    identifier: ValueSetIdentifier;
-    description?: string;
-    concept?: Concept[];
-    compose?: ValueSetCompose;
-}
-interface BindingTypeSchema {
-    identifier: BindingIdentifier;
-    description?: string;
-    type?: Identifier;
-    strength?: string;
-    enum?: string[];
-    valueset?: ValueSetIdentifier;
-    dependencies?: Identifier[];
-}
-type Field = RegularField | ChoiceFieldDeclaration | ChoiceFieldInstance;
+
+type Register = {
+    testAppendFs(fs: FHIRSchema): void;
+    ensureSpecializationCanonicalUrl(name: string | Name | CanonicalUrl): CanonicalUrl;
+    resolveSd(pkg: PackageMeta, canonicalUrl: CanonicalUrl): StructureDefinition$1 | undefined;
+    resolveFs(pkg: PackageMeta, canonicalUrl: CanonicalUrl): RichFHIRSchema | undefined;
+    resolveFsGenealogy(pkg: PackageMeta, canonicalUrl: CanonicalUrl): RichFHIRSchema[];
+    resolveFsSpecializations(pkg: PackageMeta, canonicalUrl: CanonicalUrl): RichFHIRSchema[];
+    allSd(): RichStructureDefinition[];
+    patchSd(fn: (pkg: PackageMeta, sd: StructureDefinition$1) => StructureDefinition$1): void;
+    allFs(): RichFHIRSchema[];
+    allVs(): RichValueSet[];
+    resolveVs(_pkg: PackageMeta, canonicalUrl: CanonicalUrl): RichValueSet | undefined;
+    resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
+    resolveElementSnapshot(fhirSchema: RichFHIRSchema, path: string[]): FHIRSchemaElement;
+    getAllElementKeys(elems: Record<string, FHIRSchemaElement>): string[];
+    resolver: PackageAwareResolver;
+    resolutionTree: () => ResolutionTree;
+};
+type PkgId = string;
+type PkgName = string;
+type FocusedResource = StructureDefinition$1 | ValueSet | CodeSystem;
+type CanonicalResolution<T> = {
+    deep: number;
+    pkg: PackageMeta;
+    pkgId: PkgId;
+    resource: T;
+};
+type PackageIndex = {
+    pkg: PackageMeta;
+    canonicalResolution: Record<CanonicalUrl, CanonicalResolution<FocusedResource>[]>;
+    fhirSchemas: Record<CanonicalUrl, RichFHIRSchema>;
+    valueSets: Record<CanonicalUrl, RichValueSet>;
+};
+type PackageAwareResolver = Record<PkgId, PackageIndex>;
+type ResolutionTree = Record<PkgName, Record<CanonicalUrl, {
+    deep: number;
+    pkg: PackageMeta;
+}[]>>;
 
 type FileSystemWriterOptions = {
     outputDir: string;
@@ -323,237 +853,21 @@ type CSharpGeneratorOptions = WriterOptions & {
 type StringFormatKey = "snake_case" | "PascalCase" | "camelCase";
 interface PythonGeneratorOptions extends WriterOptions {
     allowExtraFields?: boolean;
-    staticDir?: string;
     rootPackageName: string;
     fieldFormat: StringFormatKey;
+    fhirpyClient?: boolean;
 }
 
-type TreeShake = Record<string, Record<string, TreeShakeRule>>;
-type TreeShakeRule = {
-    ignoreFields?: string[];
-    selectFields?: string[];
-};
-
-/**
- * New Config Schema for High-Level API
- *
- * Simple configuration system compatible ONLY with the new high-level APIBuilder.
- * All legacy config functionality has been removed.
- */
-/**
- * TypeScript generator configuration options
- */
-interface TypeScriptGeneratorConfig {
-    moduleFormat?: "esm" | "cjs";
-    generateIndex?: boolean;
-    includeDocuments?: boolean;
-    namingConvention?: "PascalCase" | "camelCase";
-    strictMode?: boolean;
-    includeProfiles?: boolean;
-    includeExtensions?: boolean;
-    includeCodeSystems?: boolean;
-    includeOperations?: boolean;
-    /** Generate individual TypeScript files for value sets (default: false) */
-    generateValueSets?: boolean;
-    /** Include helper validation functions in value set files (default: false) */
-    includeValueSetHelpers?: boolean;
-    /** Which binding strengths to generate value sets for (default: ['required']) */
-    valueSetStrengths?: ("required" | "preferred" | "extensible" | "example")[];
-    /** Directory name for value set files (relative to outputDir) (default: 'valuesets') */
-    valueSetDirectory?: string;
-    /** Value set generation mode (default: 'required-only') */
-    valueSetMode?: "all" | "required-only" | "custom";
-    fhirVersion?: "R4" | "R5";
-    resourceTypes?: string[];
-    maxDepth?: number;
-    profileOptions?: {
-        generateKind?: "interface" | "type" | "both";
-        includeConstraints?: boolean;
-        includeDocumentation?: boolean;
-        strictMode?: boolean;
-        subfolder?: string;
-    };
-    generateBuilders?: boolean;
-    builderOptions?: {
-        includeValidation?: boolean;
-        includeFactoryMethods?: boolean;
-        includeInterfaces?: boolean;
-        generateNestedBuilders?: boolean;
-        includeHelperMethods?: boolean;
-        supportPartialBuild?: boolean;
-        includeJSDoc?: boolean;
-        generateFactories?: boolean;
-        includeTypeGuards?: boolean;
-        handleChoiceTypes?: boolean;
-        generateArrayHelpers?: boolean;
-    };
-    validatorOptions?: {
-        includeCardinality?: boolean;
-        includeTypes?: boolean;
-        includeConstraints?: boolean;
-        includeInvariants?: boolean;
-        validateRequired?: boolean;
-        allowAdditional?: boolean;
-        strictValidation?: boolean;
-        collectMetrics?: boolean;
-        generateAssertions?: boolean;
-        generatePartialValidators?: boolean;
-        optimizePerformance?: boolean;
-        includeJSDoc?: boolean;
-        generateCompositeValidators?: boolean;
-    };
-    guardOptions?: {
-        includeRuntimeValidation?: boolean;
-        includeErrorMessages?: boolean;
-        treeShakeable?: boolean;
-        targetTSVersion?: "3.8" | "4.0" | "4.5" | "5.0";
-        strictGuards?: boolean;
-        includeNullChecks?: boolean;
-        verbose?: boolean;
-    };
-}
-/**
- * TypeSchema Configuration
- * Controls TypeSchema generation and caching behavior
- */
-interface TypeSchemaConfig {
-    /** Enable persistent caching of generated TypeSchemas */
-    enablePersistence?: boolean;
-    /** Directory to store cached TypeSchemas (relative to outputDir) */
-    cacheDir?: string;
-    /** Maximum age of cached schemas in milliseconds before regeneration */
-    maxAge?: number;
-    /** Whether to validate cached schemas before reuse */
-    validateCached?: boolean;
-    /** Force regeneration of schemas even if cached */
-    forceRegenerate?: boolean;
-    /** Share cache across multiple codegen runs */
-    shareCache?: boolean;
-    /** Cache key prefix for namespacing */
-    cacheKeyPrefix?: string;
-    /** Only generate TypeSchemas for specific ResourceTypes (treeshaking) */
-    treeshake?: string[];
-    /** Generate single TypeSchema file instead of multiple files */
-    singleFile?: boolean;
-    /** Profile packages configuration */
-    profiles?: {
-        /** Auto-detect profiles in packages */
-        autoDetect?: boolean;
-    };
-}
-/**
- * Main configuration schema for the new high-level API
- */
-interface Config {
-    outputDir?: string;
-    verbose?: boolean;
-    overwrite?: boolean;
-    validate?: boolean;
-    cache?: boolean;
-    cleanOutput?: boolean;
-    typescript?: TypeScriptGeneratorConfig;
-    typeSchema?: TypeSchemaConfig;
-    packages?: string[];
-    files?: string[];
-    /** Custom FHIR package registry URL (default: https://fs.get-ig.org/pkgs/) */
-    registry?: string;
-    $schema?: string;
-}
-/**
- * Default configuration values
- */
-declare const DEFAULT_CONFIG: Required<Config>;
-/**
- * Configuration file names to search for
- */
-declare const CONFIG_FILE_NAMES: string[];
-/**
- * Validation error interface
- */
-interface ConfigValidationError {
-    path: string;
-    message: string;
-    value?: unknown;
-}
-/**
- * Configuration validation result
- */
-interface ConfigValidationResult {
-    valid: boolean;
-    errors: ConfigValidationError[];
-    warnings: string[];
-    config?: Config;
-}
-/**
- * Simple configuration validator
- */
-declare class ConfigValidator {
-    /**
-     * Validate a configuration object
-     */
-    validate(config: unknown): ConfigValidationResult;
-    private validateTypeScriptConfig;
-    private validateValidatorOptions;
-    private validateGuardOptions;
-    private validateProfileOptions;
-    private validateTypeSchemaConfig;
+interface IntrospectionWriterOptions extends FileSystemWriterOptions {
+    typeSchemas?: string /** if .ndjson -- put in one file, else -- split into separated files*/;
+    typeTree?: string /** .json or .yaml file */;
+    fhirSchemas?: string /** if .ndjson -- put in one file, else -- split into separated files*/;
+    structureDefinitions?: string /** if .ndjson -- put in one file, else -- split into separated files*/;
 }
-/**
- * Configuration loader with autoloading capabilities
- */
-declare class ConfigLoader {
-    private validator;
-    /**
-     * Auto-load configuration from the current working directory
-     */
-    autoload(workingDir?: string): Promise<Config>;
-    /**
-     * Load configuration from a specific file
-     */
-    loadFromFile(filePath: string): Promise<Config>;
-    /**
-     * Find configuration file in the given directory
-     */
-    private findConfigFile;
-    /**
-     * Merge user config with defaults
-     */
-    private mergeWithDefaults;
+
+interface IrReportWriterWriterOptions extends FileSystemWriterOptions {
+    rootReadmeFileName: string;
 }
-/**
- * Global config loader instance
- */
-declare const configLoader: ConfigLoader;
-/**
- * Convenience function to auto-load configuration
- */
-declare function loadConfig(workingDir?: string): Promise<Config>;
-/**
- * Type guard to check if an object is a valid Config
- */
-declare function isConfig(obj: unknown): obj is Config;
-/**
- * Define configuration with type safety and IntelliSense support.
- * Similar to Vite's defineConfig function pattern.
- *
- * @example
- * ```typescript
- * import { defineConfig } from "@atomic-ehr/codegen";
- *
- * export default defineConfig({
- *   outputDir: "./generated",
- *   packages: [
- *     "hl7.fhir.r4.core@4.0.1",
- *     "hl7.fhir.us.core@6.1.0"
- *   ],
- *   typescript: {
- *     generateIndex: true,
- *     strictMode: true
- *   }
- * });
- * ```
- */
-declare function defineConfig(config: Config): Config;
 
 type NameTransformation = {
     pattern: RegExp | string;
@@ -626,26 +940,16 @@ type TypeScriptOptions = {
  * Configuration options for the API builder
  */
 interface APIBuilderOptions {
-    outputDir?: string;
-    overwrite?: boolean;
-    cache?: boolean;
-    cleanOutput?: boolean;
-    typeSchemaConfig?: TypeSchemaConfig;
-    logger?: CodegenLogger;
-    manager?: ReturnType<typeof CanonicalManager> | null;
-    typeSchemaOutputDir?: string /** if .ndjson -- put in one file, else -- split into separated files*/;
-    throwException?: boolean;
-    exportTypeTree?: string;
-    treeShake?: TreeShake;
+    outputDir: string;
+    cleanOutput: boolean;
+    throwException: boolean;
+    treeShake: TreeShakeConf | undefined;
+    promoteLogical: LogicalPromotionConf | undefined;
     /** Log level for the logger. Default: INFO */
-    logLevel?: LogLevel;
+    logLevel: LogLevel;
     /** Custom FHIR package registry URL (default: https://fs.get-ig.org/pkgs/) */
-    registry?: string;
+    registry: string | undefined;
 }
-/**
- * Progress callback for long-running operations
- */
-type ProgressCallback = (phase: string, current: number, total: number, message?: string) => void;
 type GenerationReport = {
     success: boolean;
     outputDir: string;
@@ -667,16 +971,17 @@ interface LocalStructureDefinitionConfig {
  * from FHIR packages or TypeSchema documents.
  */
 declare class APIBuilder {
-    private schemas;
     private options;
-    private generators;
+    private manager;
+    private prebuiltRegister;
+    private managerInput;
     private logger;
-    private packages;
-    private localStructurePackages;
-    private localTgzArchives;
-    progressCallback: any;
-    private typeSchemaConfig?;
-    constructor(options?: APIBuilderOptions);
+    private generators;
+    constructor(userOpts?: Partial<APIBuilderOptions> & {
+        manager?: ReturnType<typeof CanonicalManager>;
+        register?: Register;
+        logger?: CodegenLogger;
+    });
     fromPackage(packageName: string, version?: string): APIBuilder;
     fromPackageRef(packageRef: string): APIBuilder;
     /**
@@ -686,15 +991,11 @@ declare class APIBuilder {
     registry(url: string): APIBuilder;
     localStructureDefinitions(config: LocalStructureDefinitionConfig): APIBuilder;
     localTgzPackage(archivePath: string): APIBuilder;
-    fromSchemas(schemas: TypeSchema[]): APIBuilder;
+    introspection(userOpts?: Partial<IntrospectionWriterOptions>): APIBuilder;
     typescript(userOpts: Partial<TypeScriptOptions>): this;
     python(userOptions: Partial<PythonGeneratorOptions>): APIBuilder;
     mustache(templatePath: string, userOpts: Partial<FileSystemWriterOptions & FileBasedMustacheGeneratorOptions>): this;
     csharp(userOptions: Partial<CSharpGeneratorOptions>): APIBuilder;
-    /**
-     * Set a progress callback for monitoring generation
-     */
-    onProgress(callback: ProgressCallback): APIBuilder;
     /**
      * Set the output directory for all generators
      */
@@ -702,18 +1003,13 @@ declare class APIBuilder {
     setLogLevel(level: LogLevel | LogLevelString): APIBuilder;
     throwException(enabled?: boolean): APIBuilder;
     cleanOutput(enabled?: boolean): APIBuilder;
-    writeTypeTree(filename: string): this;
-    treeShake(tree: TreeShake): this;
-    writeTypeSchemas(target: string): this;
+    typeSchema(cfg: IrConf): this;
+    irReport(userOpts: Partial<IrReportWriterWriterOptions>): this;
     generate(): Promise<GenerationReport>;
     /**
      * Clear all configuration and start fresh
      */
     reset(): APIBuilder;
-    /**
-     * Get loaded schemas (for inspection)
-     */
-    getSchemas(): TypeSchema[];
     /**
      * Get configured generators (for inspection)
      */
@@ -721,4 +1017,4 @@ declare class APIBuilder {
     private executeGenerators;
 }
 
-export { APIBuilder, type APIBuilderOptions, CONFIG_FILE_NAMES, type CSharpGeneratorOptions, type Config, ConfigLoader, type ConfigValidationError, type ConfigValidationResult, ConfigValidator, DEFAULT_CONFIG, type LocalStructureDefinitionConfig, LogLevel, type TypeSchemaConfig, type TypeScriptGeneratorConfig, type TypeScriptOptions, configLoader, defineConfig, isConfig, loadConfig, prettyReport };
+export { APIBuilder, type APIBuilderOptions, type CSharpGeneratorOptions, type IrConf, type LocalStructureDefinitionConfig, LogLevel, type LogicalPromotionConf, type TreeShakeConf, type TypeScriptOptions, prettyReport };