TypeSchema: Rename RegularTypeSchema to SpecializationTypeSchema

docs/guides/typeschema-index.md

@@ -48,13 +48,13 @@ Why TypeSchemaIndex Matters
 Query schemas by type category:
 
 ```typescript
-collectComplexTypes(): RegularTypeSchema[]
+collectComplexTypes(): SpecializationTypeSchema[]
   Returns all complex types (datatypes, backbone elements)
 
-collectResources(): RegularTypeSchema[]
+collectResources(): SpecializationTypeSchema[]
   Returns all FHIR resources (Patient, Observation, etc.)
 
-collectLogicalModels(): RegularTypeSchema[]
+collectLogicalModels(): SpecializationTypeSchema[]
   Returns all logical models
 
 collectProfiles(): ProfileTypeSchema[]

src/api/writer-generator/csharp/csharp.ts

@@ -5,7 +5,11 @@ import { pascalCase, uppercaseFirstLetter, uppercaseFirstLetterOfEach } from "@r
 import { Writer, type WriterOptions } from "@root/api/writer-generator/writer.ts";
 import type { PartialBy } from "@root/utils/types.ts";
 import type { Field, Identifier, RegularField } from "@typeschema/types";
-import { type ChoiceFieldInstance, isChoiceDeclarationField, type RegularTypeSchema } from "@typeschema/types.ts";
+import {
+    type ChoiceFieldInstance,
+    isChoiceDeclarationField,
+    type SpecializationTypeSchema,
+} from "@typeschema/types.ts";
 import type { TypeSchemaIndex } from "@typeschema/utils.ts";
 import { formatEnumEntry, formatName } from "./formatHelper.ts";
 
@@ -49,12 +53,12 @@ const getFieldModifiers = (field: Field) => {
     return field.required ? ["required"] : [];
 };
 
-const formatClassName = (schema: RegularTypeSchema) => {
+const formatClassName = (schema: SpecializationTypeSchema) => {
     const name = prefixReservedTypeName(getResourceName(schema.identifier));
     return uppercaseFirstLetter(name);
 };
 
-const formatBaseClass = (schema: RegularTypeSchema) => {
+const formatBaseClass = (schema: SpecializationTypeSchema) => {
     return schema.base ? `: ${schema.base.name}` : "";
 };
 
@@ -122,8 +126,8 @@ export class CSharp extends Writer<CSharpGeneratorOptions> {
     }
 
     private generateAllFiles(
-        complexTypes: RegularTypeSchema[],
-        resources: RegularTypeSchema[],
+        complexTypes: SpecializationTypeSchema[],
+        resources: SpecializationTypeSchema[],
         packages: string[],
     ): void {
         this.generateUsingFile(packages);
@@ -134,7 +138,7 @@ export class CSharp extends Writer<CSharpGeneratorOptions> {
         this.generateHelperFile();
     }
 
-    private generateType(schema: RegularTypeSchema, packageName: string): void {
+    private generateType(schema: SpecializationTypeSchema, packageName: string): void {
         const className = formatClassName(schema);
         const baseClass = formatBaseClass(schema);
 
@@ -147,7 +151,7 @@ export class CSharp extends Writer<CSharpGeneratorOptions> {
         this.line();
     }
 
-    private generateFields(schema: RegularTypeSchema, packageName: string): void {
+    private generateFields(schema: SpecializationTypeSchema, packageName: string): void {
         if (!schema.fields) return;
 
         const sortedFields = Object.entries(schema.fields).sort(([a], [b]) => a.localeCompare(b));
@@ -157,7 +161,7 @@ export class CSharp extends Writer<CSharpGeneratorOptions> {
         }
     }
 
-    private generateNestedTypes(schema: RegularTypeSchema, packageName: string): void {
+    private generateNestedTypes(schema: SpecializationTypeSchema, packageName: string): void {
         if (!("nested" in schema) || !schema.nested) return;
 
         this.line();
@@ -257,7 +261,7 @@ export class CSharp extends Writer<CSharpGeneratorOptions> {
         for (const using of globalUsings) this.lineSM("global", "using", using);
     }
 
-    private generateBaseTypes(complexTypes: RegularTypeSchema[]): void {
+    private generateBaseTypes(complexTypes: SpecializationTypeSchema[]): void {
         this.cd("/", async () => {
             this.cat("base.cs", () => {
                 this.generateDisclaimer();
@@ -272,11 +276,11 @@ export class CSharp extends Writer<CSharpGeneratorOptions> {
         });
     }
 
-    private generateResources(resources: RegularTypeSchema[]): void {
+    private generateResources(resources: SpecializationTypeSchema[]): void {
         for (const schema of resources) this.generateResourceFile(schema);
     }
 
-    private generateResourceFile(schema: RegularTypeSchema): void {
+    private generateResourceFile(schema: SpecializationTypeSchema): void {
         const packageName = formatName(schema.identifier.package);
 
         this.cd(`/${packageName}`, async () => {
@@ -328,7 +332,7 @@ export class CSharp extends Writer<CSharpGeneratorOptions> {
         this.line();
     }
 
-    private generateResourceDictionaries(resources: RegularTypeSchema[], packages: string[]): void {
+    private generateResourceDictionaries(resources: SpecializationTypeSchema[], packages: string[]): void {
         this.cd("/", async () => {
             for (const packageName of packages) {
                 const packageResources = resources.filter((r) => formatName(r.identifier.package) === packageName);
@@ -345,7 +349,7 @@ export class CSharp extends Writer<CSharpGeneratorOptions> {
         });
     }
 
-    private generateResourceDictionaryClass(packageName: string, resources: RegularTypeSchema[]): void {
+    private generateResourceDictionaryClass(packageName: string, resources: SpecializationTypeSchema[]): void {
         this.curlyBlock(["public", "static", "class", "ResourceDictionary"], () => {
             this.curlyBlock(["public static readonly Dictionary<Type, string> Map = new()"], () => {
                 for (const schema of resources) {

src/api/writer-generator/python.ts

@@ -5,7 +5,7 @@ import { fileURLToPath } from "node:url";
 import { camelCase, pascalCase, snakeCase, uppercaseFirstLetterOfEach } from "@root/api/writer-generator/utils";
 import { Writer, type WriterOptions } from "@root/api/writer-generator/writer.ts";
 import { groupByPackages, sortAsDeclarationSequence, type TypeSchemaIndex } from "@root/typeschema/utils";
-import type { EnumDefinition, Field, Identifier, RegularTypeSchema } from "@typeschema/types.ts";
+import type { EnumDefinition, Field, Identifier, SpecializationTypeSchema } from "@typeschema/types.ts";
 
 const PRIMITIVE_TYPE_MAP: Record<string, string> = {
     boolean: "bool",
@@ -148,8 +148,8 @@ const resolvePyAssets = (fn: string) => {
 };
 
 type TypeSchemaPackageGroups = {
-    groupedResources: Record<string, RegularTypeSchema[]>;
-    groupedComplexTypes: Record<string, RegularTypeSchema[]>;
+    groupedResources: Record<string, SpecializationTypeSchema[]>;
+    groupedComplexTypes: Record<string, SpecializationTypeSchema[]>;
 };
 
 export class Python extends Writer<PythonGeneratorOptions> {
@@ -191,7 +191,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         this.generateResourcePackages(groups);
     }
 
-    private generateComplexTypesPackages(groupedComplexTypes: Record<string, RegularTypeSchema[]>): void {
+    private generateComplexTypesPackages(groupedComplexTypes: Record<string, SpecializationTypeSchema[]>): void {
         for (const [packageName, packageComplexTypes] of Object.entries(groupedComplexTypes)) {
             this.cd(`/${snakeCase(packageName)}`, () => {
                 this.generateBasePy(packageComplexTypes);
@@ -213,8 +213,8 @@ export class Python extends Writer<PythonGeneratorOptions> {
 
     private generateResourcePackageContent(
         packageName: string,
-        packageResources: RegularTypeSchema[],
-        packageComplexTypes: RegularTypeSchema[],
+        packageResources: SpecializationTypeSchema[],
+        packageComplexTypes: SpecializationTypeSchema[],
     ): void {
         const pyPackageName = this.pyFhirPackageByName(packageName);
 
@@ -255,7 +255,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         }
     }
 
-    private generateBasePy(packageComplexTypes: RegularTypeSchema[]): void {
+    private generateBasePy(packageComplexTypes: SpecializationTypeSchema[]): void {
         const hasGenericTypes = packageComplexTypes.some((s) => s.identifier.name in GENERIC_FIELD_REWRITES);
         this.cat("base.py", () => {
             this.generateDisclaimer();
@@ -270,7 +270,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         });
     }
 
-    private generateComplexTypes(complexTypes: RegularTypeSchema[]): void {
+    private generateComplexTypes(complexTypes: SpecializationTypeSchema[]): void {
         for (const schema of sortAsDeclarationSequence(complexTypes)) {
             this.generateNestedTypes(schema);
             this.line();
@@ -280,8 +280,8 @@ export class Python extends Writer<PythonGeneratorOptions> {
 
     private generateResourcePackageInit(
         fullPyPackageName: string,
-        packageResources: RegularTypeSchema[],
-        packageComplexTypes?: RegularTypeSchema[],
+        packageResources: SpecializationTypeSchema[],
+        packageComplexTypes?: SpecializationTypeSchema[],
     ): void {
         this.cat("__init__.py", () => {
             this.generateDisclaimer();
@@ -292,7 +292,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         });
     }
 
-    private importComplexTypes(fullPyPackageName: string, packageComplexTypes?: RegularTypeSchema[]): string[] {
+    private importComplexTypes(fullPyPackageName: string, packageComplexTypes?: SpecializationTypeSchema[]): string[] {
         if (!packageComplexTypes || packageComplexTypes.length === 0) return [];
 
         const baseTypes = packageComplexTypes.map((t) => t.identifier.name).sort();
@@ -323,7 +323,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
     private importResources(
         fullPyPackageName: string,
         importEmptyResources: boolean,
-        packageResources?: RegularTypeSchema[],
+        packageResources?: SpecializationTypeSchema[],
     ): string[] {
         if (!packageResources || packageResources.length === 0) return [];
         const allResourceNames: string[] = [];
@@ -337,7 +337,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         return allResourceNames;
     }
 
-    private importOneResource(resource: RegularTypeSchema, fullPyPackageName: string): string[] {
+    private importOneResource(resource: SpecializationTypeSchema, fullPyPackageName: string): string[] {
         const moduleName = `${fullPyPackageName}.${snakeCase(resource.identifier.name)}`;
         const importNames = this.collectResourceImportNames(resource);
 
@@ -353,7 +353,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         return names;
     }
 
-    private collectResourceImportNames(resource: RegularTypeSchema): string[] {
+    private collectResourceImportNames(resource: SpecializationTypeSchema): string[] {
         const names = [deriveResourceName(resource.identifier)];
 
         for (const nested of resource.nested ?? []) {
@@ -364,12 +364,12 @@ export class Python extends Writer<PythonGeneratorOptions> {
         return names;
     }
 
-    private shouldImportResourceFamily(resource: RegularTypeSchema): boolean {
+    private shouldImportResourceFamily(resource: SpecializationTypeSchema): boolean {
         return resource.identifier.kind === "resource" && (resource.typeFamily?.resources?.length ?? 0) > 0;
     }
 
     private generateExportsDeclaration(
-        packageComplexTypes: RegularTypeSchema[] | undefined,
+        packageComplexTypes: SpecializationTypeSchema[] | undefined,
         allResourceNames: string[],
     ): void {
         this.squareBlock(["__all__", "="], () => {
@@ -384,7 +384,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         });
     }
 
-    private generateResourceModule(schema: RegularTypeSchema): void {
+    private generateResourceModule(schema: SpecializationTypeSchema): void {
         this.cat(`${snakeCase(schema.identifier.name)}.py`, () => {
             this.generateDisclaimer();
             this.generateDefaultImports(false);
@@ -403,7 +403,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
             this.pyImportFrom(`${this.opts.rootPackageName}.fhirpy_base_model`, "FhirpyBaseModel");
     }
 
-    private generateType(schema: RegularTypeSchema): void {
+    private generateType(schema: SpecializationTypeSchema): void {
         const className = deriveResourceName(schema.identifier);
         const superClasses = this.getSuperClasses(schema);
 
@@ -414,15 +414,15 @@ export class Python extends Writer<PythonGeneratorOptions> {
         this.line();
     }
 
-    private getSuperClasses(schema: RegularTypeSchema): string[] {
+    private getSuperClasses(schema: SpecializationTypeSchema): string[] {
         const bases: string[] = [];
         if (schema.base) bases.push(schema.base.name);
         bases.push(...this.injectSuperClasses(schema.identifier.url));
         if (schema.identifier.name in GENERIC_FIELD_REWRITES) bases.push("Generic[T]");
         return bases;
     }
 
-    private generateClassBody(schema: RegularTypeSchema): void {
+    private generateClassBody(schema: SpecializationTypeSchema): void {
         this.generateModelConfig();
 
         if (!schema.fields) {
@@ -446,7 +446,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         this.line(`model_config = ConfigDict(validate_by_name=True, serialize_by_alias=True, extra="${extraMode}")`);
     }
 
-    private generateResourceTypeField(schema: RegularTypeSchema): void {
+    private generateResourceTypeField(schema: SpecializationTypeSchema): void {
         const hasChildren = (schema.typeFamily?.resources?.length ?? 0) > 0;
 
         if (hasChildren) {
@@ -467,7 +467,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         this.line(")");
     }
 
-    private generateFields(schema: RegularTypeSchema, schemaName: string): void {
+    private generateFields(schema: SpecializationTypeSchema, schemaName: string): void {
         const sortedFields = Object.entries(schema.fields ?? []).sort(([a], [b]) => a.localeCompare(b));
 
         for (const [fieldName, field] of sortedFields) {
@@ -544,7 +544,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         return ` = Field(${aliasSpec})`;
     }
 
-    private generateResourceMethods(schema: RegularTypeSchema): void {
+    private generateResourceMethods(schema: SpecializationTypeSchema): void {
         const className = schema.identifier.name.toString();
 
         this.line();
@@ -556,7 +556,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         this.line("    return cls.model_validate_json(json)");
     }
 
-    private generateNestedTypes(schema: RegularTypeSchema): void {
+    private generateNestedTypes(schema: SpecializationTypeSchema): void {
         if (!schema.nested) return;
 
         this.line();
@@ -578,7 +578,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         }
     }
 
-    private generateDependenciesImports(schema: RegularTypeSchema): void {
+    private generateDependenciesImports(schema: SpecializationTypeSchema): void {
         if (!schema.dependencies || schema.dependencies.length === 0) return;
 
         this.importComplexTypeDependencies(schema.dependencies);
@@ -650,7 +650,7 @@ export class Python extends Writer<PythonGeneratorOptions> {
         this.pyImportFrom(this.pyPackage(identifier), pascalCase(identifier.name));
     }
 
-    private generateResourceFamilies(packageResources: RegularTypeSchema[]): void {
+    private generateResourceFamilies(packageResources: SpecializationTypeSchema[]): void {
         assert(this.tsIndex !== undefined);
         const packages = //this.helper.getPackages(packageResources, this.opts.rootPackageName);
             Object.keys(groupByPackages(packageResources)).map(

src/api/writer-generator/typescript/writer.ts

@@ -15,7 +15,7 @@ import {
     type Name,
     packageMeta,
     packageMetaToFhir,
-    type RegularTypeSchema,
+    type SpecializationTypeSchema,
     type TypeSchema,
 } from "@root/typeschema/types";
 import { groupByPackages, type TypeSchemaIndex } from "@root/typeschema/utils";
@@ -145,7 +145,7 @@ export class TypeScript extends Writer<TypeScriptOptions> {
         });
     }
 
-    generateDependenciesImports(tsIndex: TypeSchemaIndex, schema: RegularTypeSchema, importPrefix = "../") {
+    generateDependenciesImports(tsIndex: TypeSchemaIndex, schema: SpecializationTypeSchema, importPrefix = "../") {
         if (schema.dependencies) {
             const imports = [];
             const skipped = [];
@@ -191,7 +191,7 @@ export class TypeScript extends Writer<TypeScriptOptions> {
         }
     }
 
-    generateComplexTypeReexports(schema: RegularTypeSchema) {
+    generateComplexTypeReexports(schema: SpecializationTypeSchema) {
         const complexTypeDeps = schema.dependencies?.filter(isComplexTypeIdentifier);
         if (complexTypeDeps && complexTypeDeps.length > 0) {
             for (const dep of complexTypeDeps) {
@@ -208,7 +208,7 @@ export class TypeScript extends Writer<TypeScriptOptions> {
         this.lineSM(`${extFieldName}?: ${typeExpr}`);
     }
 
-    generateType(tsIndex: TypeSchemaIndex, schema: RegularTypeSchema) {
+    generateType(tsIndex: TypeSchemaIndex, schema: SpecializationTypeSchema) {
         let name: string;
         // Generic types: Reference, Coding, CodeableConcept
         const genericTypes = ["Reference", "Coding", "CodeableConcept"];
@@ -307,7 +307,7 @@ export class TypeScript extends Writer<TypeScriptOptions> {
         return false;
     }
 
-    generateResourceTypePredicate(schema: RegularTypeSchema) {
+    generateResourceTypePredicate(schema: SpecializationTypeSchema) {
         if (!isResourceTypeSchema(schema)) return;
         const name = tsResourceName(schema.identifier);
         this.curlyBlock(["export", "const", `is${name}`, "=", `(resource: unknown): resource is ${name}`, "=>"], () => {
@@ -317,7 +317,7 @@ export class TypeScript extends Writer<TypeScriptOptions> {
         });
     }
 
-    generateNestedTypes(tsIndex: TypeSchemaIndex, schema: RegularTypeSchema) {
+    generateNestedTypes(tsIndex: TypeSchemaIndex, schema: SpecializationTypeSchema) {
         if (schema.nested) {
             for (const subtype of schema.nested) {
                 this.generateType(tsIndex, subtype);