@atomic-ehr/codegen 0.0.1-canary.20250924120719.44f2f7c → 0.0.1-canary.20250927094522.7f26cfe

package/dist/typeschema/schema.js

@@ -1,456 +0,0 @@
-export const validationSchema = {
-    $schema: "http://json-schema.org/draft-07/schema#",
-    $id: "https://fhir-clj.github.io/type-schema/json-schema/type-schema.json",
-    $comment: "Maturity Level: Draft",
-    title: "Type Schema",
-    description: "A code generation friendly representation of FHIR StructureDefinition and FHIR Schema designed to simplify SDK resource classes/types generation.",
-    type: "object",
-    definitions: {
-        "type-schema-identifier": {
-            type: "object",
-            oneOf: [
-                { $ref: "#/definitions/with-primitive-type-kind" },
-                { $ref: "#/definitions/with-valueset-kind" },
-                { $ref: "#/definitions/with-complex-type-kind" },
-                { $ref: "#/definitions/with-resource-kind" },
-                { $ref: "#/definitions/with-nested-kind" },
-                { $ref: "#/definitions/with-logical-kind" },
-                { $ref: "#/definitions/with-binding-kind" },
-            ],
-            properties: {
-                kind: {
-                    type: "string",
-                },
-                package: {
-                    type: "string",
-                    description: "The FHIR package identifier (e.g., hl7.fhir.r4.core)",
-                },
-                version: {
-                    type: "string",
-                    description: "The version of the package",
-                },
-                name: {
-                    type: "string",
-                    description: "Computer friendly identifier for the element",
-                },
-                url: {
-                    type: "string",
-                    pattern: "^(https?://|urn:)[^\\s]+$",
-                    description: "A canonical URL identifying this resource uniquely in the FHIR ecosystem",
-                },
-            },
-            required: ["kind", "package", "version", "name", "url"],
-            additionalProperties: false,
-        },
-        "with-primitive-type-kind": {
-            type: "object",
-            description: "Constraint helper to ensure the kind is primitive-type",
-            properties: {
-                kind: { const: "primitive-type" },
-            },
-        },
-        "with-valueset-kind": {
-            type: "object",
-            description: "Constraint helper to ensure the kind is value-set",
-            properties: {
-                kind: { const: "value-set" },
-            },
-        },
-        "with-binding-kind": {
-            type: "object",
-            description: "Constraint helper to ensure the kind is value-set",
-            properties: {
-                kind: { const: "binding" },
-            },
-        },
-        "with-complex-type-kind": {
-            type: "object",
-            description: "Constraint helper to ensure the kind is complex-type",
-            properties: {
-                kind: { const: "complex-type" },
-            },
-        },
-        "with-resource-kind": {
-            type: "object",
-            description: "Constraint helper to ensure the kind is resource",
-            properties: {
-                kind: { const: "resource" },
-            },
-        },
-        "with-nested-kind": {
-            type: "object",
-            description: "Constraint helper to ensure the kind is nested",
-            properties: {
-                kind: { const: "nested" },
-            },
-        },
-        "with-logical-kind": {
-            type: "object",
-            description: "Constraint helper to ensure the kind is logical",
-            properties: {
-                kind: { const: "logical" },
-            },
-        },
-        "field.regular": {
-            title: "Regular field",
-            description: "A standard field with a single type",
-            type: "object",
-            properties: {
-                type: {
-                    $ref: "#/definitions/type-schema-identifier",
-                    description: "The data type of this field",
-                },
-                reference: {
-                    type: "array",
-                    description: "Reference to other types that this field can point to",
-                    items: {
-                        $ref: "#/definitions/type-schema-identifier",
-                    },
-                },
-                required: {
-                    type: "boolean",
-                    default: false,
-                    description: "Whether this field must be provided in valid instances",
-                },
-                excluded: {
-                    type: "boolean",
-                    default: false,
-                    description: "Whether this field is prohibited in valid instances",
-                },
-                array: {
-                    type: "boolean",
-                    default: false,
-                    description: "Whether this field can contain multiple values (cardinality > 1)",
-                },
-                binding: {
-                    allOf: [
-                        { $ref: "#/definitions/type-schema-identifier" },
-                        { $ref: "#/definitions/with-binding-kind" },
-                    ],
-                },
-                enum: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "For code fields, the set of valid values when bound to a required value set",
-                },
-                min: {
-                    type: "number",
-                    description: "Minimum limit of items for an array",
-                },
-                max: {
-                    type: "number",
-                    description: "Maximum limit of items for an array",
-                },
-            },
-            required: ["type"],
-            additionalProperties: false,
-        },
-        "field.polymorphic-declaration": {
-            title: "Polymorphic value[x] field declaration",
-            description: "The base declaration for a FHIR choice type (e.g., value[x])",
-            type: "object",
-            properties: {
-                choices: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "The names of all concrete type options for this choice field",
-                },
-                required: {
-                    type: "boolean",
-                    default: false,
-                    description: "Whether at least one choice must be provided",
-                },
-                excluded: {
-                    type: "boolean",
-                    default: false,
-                    description: "Whether all choices are prohibited",
-                },
-                array: {
-                    type: "boolean",
-                    default: false,
-                    description: "Whether the selected choice can contain multiple values",
-                },
-                min: {
-                    type: "number",
-                    description: "Minimum limit of items for an array",
-                },
-                max: {
-                    type: "number",
-                    description: "Maximum limit of items for an array",
-                },
-            },
-            required: ["choices"],
-            additionalProperties: false,
-        },
-        "field.polymorphic-instance": {
-            title: "Polymorphic value[x] field instance",
-            description: "A specific type option for a FHIR choice type (e.g., valueString, valueInteger)",
-            type: "object",
-            properties: {
-                choiceOf: {
-                    type: "string",
-                    description: "The name of the choice field this instance belongs to (e.g., 'value' for valueString)",
-                },
-                type: {
-                    $ref: "#/definitions/type-schema-identifier",
-                    description: "The data type of this choice option",
-                },
-                required: {
-                    type: "boolean",
-                    default: false,
-                    description: "Whether this specific choice must be provided",
-                },
-                excluded: {
-                    type: "boolean",
-                    default: false,
-                    description: "Whether this specific choice is prohibited",
-                },
-                array: {
-                    type: "boolean",
-                    default: false,
-                    description: "Whether this choice can contain multiple values",
-                },
-                reference: {
-                    type: "array",
-                    description: "Reference to other types that this field can point to",
-                    items: {
-                        $ref: "#/definitions/type-schema-identifier",
-                    },
-                },
-                binding: {
-                    allOf: [
-                        { $ref: "#/definitions/type-schema-identifier" },
-                        { $ref: "#/definitions/with-binding-kind" },
-                    ],
-                    description: "For coded choices, information about the value set binding",
-                },
-                enum: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "For code fields, the set of valid values when bound to a required value set",
-                },
-                min: {
-                    type: "number",
-                    description: "Minimum limit of items for an array",
-                },
-                max: {
-                    type: "number",
-                    description: "Maximum limit of items for an array",
-                },
-            },
-            required: ["type", "choiceOf"],
-            additionalProperties: false,
-        },
-        dependencies: {
-            type: "array",
-            description: "Other types that this type depends on",
-            items: {
-                $ref: "#/definitions/type-schema-identifier",
-            },
-        },
-    },
-    oneOf: [
-        {
-            title: "Type Schema for Primitive Type",
-            description: "Schema for basic FHIR data types like string, boolean, decimal",
-            type: "object",
-            properties: {
-                identifier: {
-                    allOf: [
-                        { $ref: "#/definitions/type-schema-identifier" },
-                        { $ref: "#/definitions/with-primitive-type-kind" },
-                    ],
-                    description: "The unique identifier for this primitive type",
-                },
-                description: {
-                    type: "string",
-                    description: "Human-readable description of the primitive type",
-                },
-                base: {
-                    $ref: "#/definitions/type-schema-identifier",
-                    description: "The base type this primitive type extends (typically Element)",
-                },
-                dependencies: {
-                    $ref: "#/definitions/dependencies",
-                    description: "Other types that this primitive type depends on",
-                },
-            },
-            required: ["identifier", "base"],
-            additionalProperties: false,
-        },
-        {
-            title: "Type Schema for Resource, Complex Type, Logical",
-            description: "Schema for FHIR resources, complex types, and logical types",
-            type: "object",
-            properties: {
-                identifier: {
-                    allOf: [
-                        { $ref: "#/definitions/type-schema-identifier" },
-                        {
-                            oneOf: [
-                                { $ref: "#/definitions/with-resource-kind" },
-                                { $ref: "#/definitions/with-complex-type-kind" },
-                                { $ref: "#/definitions/with-logical-kind" },
-                            ],
-                        },
-                    ],
-                    description: "The unique identifier for this resource or type",
-                },
-                base: {
-                    $ref: "#/definitions/type-schema-identifier",
-                    description: "The base type this resource or type extends",
-                },
-                description: {
-                    type: "string",
-                    description: "Human-readable description of the resource or type",
-                },
-                fields: {
-                    type: "object",
-                    description: "The fields contained in this resource or type",
-                    additionalProperties: {
-                        anyOf: [
-                            { $ref: "#/definitions/field.regular" },
-                            { $ref: "#/definitions/field.polymorphic-declaration" },
-                            { $ref: "#/definitions/field.polymorphic-instance" },
-                        ],
-                    },
-                },
-                nested: {
-                    type: "array",
-                    description: "BackboneElement types nested within this resource or type",
-                    items: {
-                        type: "object",
-                        properties: {
-                            identifier: {
-                                allOf: [
-                                    { $ref: "#/definitions/type-schema-identifier" },
-                                    { $ref: "#/definitions/with-nested-kind" },
-                                ],
-                                description: "The unique identifier for this nested type",
-                            },
-                            base: {
-                                $ref: "#/definitions/type-schema-identifier",
-                                description: "The base type this nested type extends (typically BackboneElement)",
-                            },
-                            fields: {
-                                type: "object",
-                                description: "The fields contained in this nested type",
-                                additionalProperties: {
-                                    anyOf: [
-                                        { $ref: "#/definitions/field.regular" },
-                                        { $ref: "#/definitions/field.polymorphic-declaration" },
-                                        { $ref: "#/definitions/field.polymorphic-instance" },
-                                    ],
-                                },
-                            },
-                        },
-                        required: ["identifier", "base"],
-                        additionalProperties: false,
-                    },
-                },
-                dependencies: {
-                    type: "array",
-                    description: "Other types that this resource or type depends on",
-                    items: {
-                        $ref: "#/definitions/type-schema-identifier",
-                    },
-                },
-            },
-            required: ["identifier"],
-            additionalProperties: false,
-        },
-        {
-            title: "Type Schema for ValueSet",
-            description: "Schema for FHIR value sets that define terminology bindings",
-            type: "object",
-            properties: {
-                identifier: {
-                    allOf: [
-                        { $ref: "#/definitions/type-schema-identifier" },
-                        { $ref: "#/definitions/with-valueset-kind" },
-                    ],
-                    description: "The unique identifier for this value set",
-                },
-                description: {
-                    type: "string",
-                    description: "Human-readable description of the value set",
-                },
-                concept: {
-                    type: "array",
-                    description: "The list of coded concepts contained in this value set",
-                    items: {
-                        type: "object",
-                        properties: {
-                            code: {
-                                type: "string",
-                                description: "The code value",
-                            },
-                            display: {
-                                type: "string",
-                                description: "The human-readable display text for this code",
-                            },
-                            system: {
-                                type: "string",
-                                description: "The code system URL that defines this code",
-                            },
-                        },
-                        required: ["code"],
-                        additionalProperties: false,
-                    },
-                },
-                compose: {
-                    type: "object",
-                    description: "Complex value set composition rules when the value set is defined as a composition of other value sets",
-                },
-            },
-            required: ["identifier"],
-            additionalProperties: false,
-        },
-        {
-            title: "Type Schema for Binding",
-            type: "object",
-            properties: {
-                identifier: {
-                    allOf: [
-                        { $ref: "#/definitions/type-schema-identifier" },
-                        { $ref: "#/definitions/with-binding-kind" },
-                    ],
-                    description: "The unique identifier for this value set",
-                },
-                description: {
-                    type: "string",
-                    description: "Human-readable description of the value set",
-                },
-                type: {
-                    $ref: "#/definitions/type-schema-identifier",
-                },
-                strength: {
-                    type: "string",
-                    description: "The strength of the binding",
-                },
-                enum: {
-                    type: "array",
-                    items: {
-                        type: "string",
-                    },
-                    description: "The enumeration of values for the binding",
-                },
-                valueset: {
-                    allOf: [
-                        { $ref: "#/definitions/type-schema-identifier" },
-                        { $ref: "#/definitions/with-valueset-kind" },
-                    ],
-                },
-                dependencies: {
-                    type: "array",
-                    description: "Other types that this resource or type depends on",
-                    items: {
-                        $ref: "#/definitions/type-schema-identifier",
-                    },
-                },
-            },
-            required: ["identifier"],
-            additionalProperties: false,
-        },
-    ],
-};

package/dist/typeschema/type-schema.types.d.ts

@@ -1,186 +0,0 @@
-/**
- * TypeScript type definitions for Type Schema
- *
- * Generated based on type-schema.schema.json
- * A code generation friendly representation of FHIR StructureDefinition
- * and FHIR Schema designed to simplify SDK resource classes/types generation.
- */
-export interface TypeSchemaIdentifierBase {
-    /** The FHIR package identifier (e.g., hl7.fhir.r4.core) */
-    package: string;
-    /** The version of the package */
-    version: string;
-    /** Computer friendly identifier for the element */
-    name: string;
-    /** A canonical URL identifying this resource uniquely in the FHIR ecosystem */
-    url: string;
-}
-export interface WithPrimitiveTypeKind {
-    kind: "primitive-type";
-}
-export interface WithValueSetKind {
-    kind: "value-set";
-}
-export interface WithBindingKind {
-    kind: "binding";
-}
-export interface WithComplexTypeKind {
-    kind: "complex-type";
-}
-export interface WithResourceKind {
-    kind: "resource";
-}
-export interface WithNestedKind {
-    kind: "nested";
-}
-export interface WithLogicalKind {
-    kind: "logical";
-}
-export type TypeSchemaIdentifier = (TypeSchemaIdentifierBase & WithPrimitiveTypeKind) | (TypeSchemaIdentifierBase & WithValueSetKind) | (TypeSchemaIdentifierBase & WithBindingKind) | (TypeSchemaIdentifierBase & WithComplexTypeKind) | (TypeSchemaIdentifierBase & WithResourceKind) | (TypeSchemaIdentifierBase & WithNestedKind) | (TypeSchemaIdentifierBase & WithLogicalKind);
-export interface RegularField {
-    /** The data type of this field */
-    type: TypeSchemaIdentifier;
-    /** Reference to other types that this field can point to */
-    reference?: TypeSchemaIdentifier[];
-    /** Whether this field must be provided in valid instances */
-    required?: boolean;
-    /** Whether this field is prohibited in valid instances */
-    excluded?: boolean;
-    /** Whether this field can contain multiple values (cardinality > 1) */
-    array?: boolean;
-    /** Binding information for coded fields */
-    binding?: TypeSchemaIdentifierBase & WithBindingKind;
-    /** For code fields, the set of valid values when bound to a required value set */
-    enum?: string[];
-    /** Minimum limit of items for an array */
-    min?: number;
-    /** Maximum limit of items for an array */
-    max?: number;
-}
-export interface PolymorphicDeclarationField {
-    /** 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;
-}
-export interface PolymorphicInstanceField {
-    /** 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: TypeSchemaIdentifier;
-    /** Whether this specific choice must be provided */
-    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?: TypeSchemaIdentifierBase & WithBindingKind;
-    /** For code fields, the set of valid values when bound to a required value set */
-    enum?: string[];
-    /** Minimum limit of items for an array */
-    min?: number;
-    /** Maximum limit of items for an array */
-    max?: number;
-}
-export type TypeSchemaField = RegularField | PolymorphicDeclarationField | PolymorphicInstanceField;
-export interface NestedType {
-    /** The unique identifier for this nested type */
-    identifier: TypeSchemaIdentifierBase & WithNestedKind;
-    /** The base type this nested type extends (typically BackboneElement) */
-    base: TypeSchemaIdentifier;
-    /** The fields contained in this nested type */
-    fields?: Record<string, TypeSchemaField>;
-}
-export interface ValueSetConcept {
-    /** 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;
-}
-export interface TypeSchemaForPrimitiveType {
-    /** The unique identifier for this primitive type */
-    identifier: TypeSchemaIdentifierBase & WithPrimitiveTypeKind;
-    /** The base type this primitive type extends (typically Element) */
-    base: TypeSchemaIdentifier;
-    /** Human-readable description of the primitive type */
-    description?: string;
-    /** Other types that this primitive type depends on */
-    dependencies?: TypeSchemaIdentifier[];
-}
-export interface TypeSchemaForResourceComplexLogical {
-    /** The unique identifier for this resource or type */
-    identifier: (TypeSchemaIdentifierBase & WithResourceKind) | (TypeSchemaIdentifierBase & WithComplexTypeKind) | (TypeSchemaIdentifierBase & WithLogicalKind);
-    /** The base type this resource or type extends */
-    base?: TypeSchemaIdentifier;
-    /** Human-readable description of the resource or type */
-    description?: string;
-    /** The fields contained in this resource or type */
-    fields?: Record<string, TypeSchemaField>;
-    /** BackboneElement types nested within this resource or type */
-    nested?: NestedType[];
-    /** Other types that this resource or type depends on */
-    dependencies?: TypeSchemaIdentifier[];
-}
-export interface TypeSchemaForValueSet {
-    /** The unique identifier for this value set */
-    identifier: TypeSchemaIdentifierBase & WithValueSetKind;
-    /** Human-readable description of the value set */
-    description?: string;
-    /** The list of coded concepts contained in this value set */
-    concept?: ValueSetConcept[];
-    /** Complex value set composition rules when the value set is defined as a composition of other value sets */
-    compose?: Record<string, unknown>;
-}
-export interface TypeSchemaForBinding {
-    /** The unique identifier for this binding */
-    identifier: TypeSchemaIdentifierBase & WithBindingKind;
-    /** Human-readable description of the binding */
-    description?: string;
-    /** The type this binding applies to */
-    type?: TypeSchemaIdentifier;
-    /** The strength of the binding */
-    strength?: string;
-    /** The enumeration of values for the binding */
-    enum?: string[];
-    /** Reference to the value set for this binding */
-    valueset?: TypeSchemaIdentifierBase & WithValueSetKind;
-    /** Other types that this binding depends on */
-    dependencies?: TypeSchemaIdentifier[];
-}
-export type TypeSchema = TypeSchemaForPrimitiveType | TypeSchemaForResourceComplexLogical | TypeSchemaForValueSet | TypeSchemaForBinding;
-export declare function isPrimitiveTypeSchema(schema: TypeSchema): schema is TypeSchemaForPrimitiveType;
-export declare function isResourceSchema(schema: TypeSchema): schema is TypeSchemaForResourceComplexLogical;
-export declare function isComplexTypeSchema(schema: TypeSchema): schema is TypeSchemaForResourceComplexLogical;
-export declare function isLogicalSchema(schema: TypeSchema): schema is TypeSchemaForResourceComplexLogical;
-export declare function isValueSetSchema(schema: TypeSchema): schema is TypeSchemaForValueSet;
-export declare function isBindingSchema(schema: TypeSchema): schema is TypeSchemaForBinding;
-export declare function isNestedTypeSchema(identifier: TypeSchemaIdentifier): identifier is TypeSchemaIdentifierBase & WithNestedKind;
-export declare function isRegularField(field: TypeSchemaField): field is RegularField;
-export declare function isPolymorphicDeclarationField(field: TypeSchemaField): field is PolymorphicDeclarationField;
-export declare function isPolymorphicInstanceField(field: TypeSchemaField): field is PolymorphicInstanceField;
-export type SchemaKind = TypeSchemaIdentifier["kind"];
-export type SchemasByKind = {
-    "primitive-type": TypeSchemaForPrimitiveType;
-    resource: TypeSchemaForResourceComplexLogical;
-    "complex-type": TypeSchemaForResourceComplexLogical;
-    logical: TypeSchemaForResourceComplexLogical;
-    "value-set": TypeSchemaForValueSet;
-    binding: TypeSchemaForBinding;
-    nested: never;
-};
-export type GetSchemaByKind<K extends SchemaKind> = K extends keyof SchemasByKind ? SchemasByKind[K] : never;
-export type ExtractFieldNames<T extends TypeSchema> = T extends TypeSchemaForResourceComplexLogical ? T["fields"] extends Record<string, any> ? keyof T["fields"] : never : never;
-export type ExtractFieldType<T extends TypeSchema, F extends string> = T extends TypeSchemaForResourceComplexLogical ? T["fields"] extends Record<string, any> ? F extends keyof T["fields"] ? T["fields"][F] : never : never : never;

package/dist/typeschema/type-schema.types.js

@@ -1,39 +0,0 @@
-/**
- * TypeScript type definitions for Type Schema
- *
- * Generated based on type-schema.schema.json
- * A code generation friendly representation of FHIR StructureDefinition
- * and FHIR Schema designed to simplify SDK resource classes/types generation.
- */
-// Type guards for discriminating between different schema types
-export function isPrimitiveTypeSchema(schema) {
-    return schema.identifier.kind === "primitive-type";
-}
-export function isResourceSchema(schema) {
-    return schema.identifier.kind === "resource";
-}
-export function isComplexTypeSchema(schema) {
-    return schema.identifier.kind === "complex-type";
-}
-export function isLogicalSchema(schema) {
-    return schema.identifier.kind === "logical";
-}
-export function isValueSetSchema(schema) {
-    return schema.identifier.kind === "value-set";
-}
-export function isBindingSchema(schema) {
-    return schema.identifier.kind === "binding";
-}
-export function isNestedTypeSchema(identifier) {
-    return identifier.kind === "nested";
-}
-// Field type guards
-export function isRegularField(field) {
-    return "type" in field && !("choiceOf" in field) && !("choices" in field);
-}
-export function isPolymorphicDeclarationField(field) {
-    return "choices" in field;
-}
-export function isPolymorphicInstanceField(field) {
-    return "choiceOf" in field && "type" in field;
-}