Function generateFlattenedBooleanDiscriminatedClass

scripts/codegen/csharp.ts:741–807

(
    baseClassName: string,
    discriminatorInfo: DiscriminatorInfo,
    knownTypes: Map<string, string>,
    nestedClasses: Map<string, string>,
    enumOutput: string[],
    description?: string,
    propertyResolver?: PropertyTypeResolver,
    experimental = false,
    options: DiscriminatedUnionGenerationOptions = {}
)

}

function generateFlattenedBooleanDiscriminatedClass(
    baseClassName: string,
    discriminatorInfo: DiscriminatorInfo,
    knownTypes: Map<string, string>,
    nestedClasses: Map<string, string>,
    enumOutput: string[],
    description?: string,
    propertyResolver?: PropertyTypeResolver,
    experimental = false,
    options: DiscriminatedUnionGenerationOptions = {}
): string {
    const resolver = propertyResolver ?? resolveSessionPropertyType;
    const renamedBase = applyTypeRename(baseClassName);
    const lines: string[] = [];
    const flattenedProperties = new Map<string, { schema: JSONSchema7; requiredCount: number; variantCount: number }>();
    const variants = Array.from(discriminatorInfo.mapping.values()).map((variant) => variant.schema);

    for (const variant of variants) {
        const required = new Set(variant.required || []);
        for (const [propName, propSchema] of Object.entries(variant.properties || {})) {
            if (typeof propSchema !== "object" || propName === discriminatorInfo.property) continue;

            const existing = flattenedProperties.get(propName);
            if (existing) {
                existing.variantCount++;
                if (required.has(propName)) existing.requiredCount++;
                continue;
            }

            flattenedProperties.set(propName, {
                schema: propSchema as JSONSchema7,
                requiredCount: required.has(propName) ? 1 : 0,
                variantCount: 1,
            });
        }
    }

    lines.push(...xmlDocCommentWithFallback(description, `Data type discriminated by <c>${escapeXml(discriminatorInfo.property)}</c>.`, ""));
    if (experimental) pushExperimentalAttribute(lines);
    lines.push(`public ${options.sealLeafTypes ? "sealed " : ""}partial class ${renamedBase}`);
    lines.push(`{`);
    lines.push(`    /// <summary>The boolean discriminator.</summary>`);
    lines.push(`    [JsonPropertyName("${discriminatorInfo.property}")]`);
    lines.push(`    public bool ${toPascalCase(discriminatorInfo.property)} { get; set; }`);

    const propertyEntries = Array.from(flattenedProperties.entries()).sort(([a], [b]) => a.localeCompare(b));
    for (const [propName, info] of propertyEntries) {
        const isReq = info.variantCount === variants.length && info.requiredCount === variants.length;
        const csharpName = toCSharpPropertyName(propName, info.schema);
        const csharpType = resolver(info.schema, renamedBase, csharpName, isReq, knownTypes, nestedClasses, enumOutput);

        lines.push("");
        lines.push(...xmlDocPropertyComment(info.schema.description, propName, "    "));
        lines.push(...emitDataAnnotations(info.schema, "    ", csharpType));
        if (isSchemaDeprecated(info.schema)) pushObsoleteAttributes(lines, "    ");
        if (isSchemaExperimental(info.schema)) pushExperimentalAttribute(lines, "    ");
        if (isMillisecondsDurationProperty(propName, info.schema)) lines.push(`    [JsonConverter(typeof(MillisecondsTimeSpanConverter))]`);
        if (!isReq) lines.push(`    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]`);