Function resolveGoPropertyType

scripts/codegen/go.ts:839–1020

* Resolve a JSON Schema property to a Go type string. * Emits nested struct/enum definitions into ctx as a side effect.

(
    propSchema: JSONSchema7,
    parentTypeName: string,
    jsonPropName: string,
    isRequired: boolean,
    ctx: GoCodegenCtx
)

 * Emits nested struct/enum definitions into ctx as a side effect.
 */
function resolveGoPropertyType(
    propSchema: JSONSchema7,
    parentTypeName: string,
    jsonPropName: string,
    isRequired: boolean,
    ctx: GoCodegenCtx
): string {
    const nestedName = parentTypeName + toGoFieldName(jsonPropName);

    // Handle $ref — resolve the reference and generate the referenced type
    if (propSchema.$ref && typeof propSchema.$ref === "string") {
        const typeName = goRefTypeName(propSchema.$ref, ctx.definitions, ctx.packageName);
        const resolved = resolveRef(propSchema.$ref, ctx.definitions);
        if (resolved) {
            if (resolved.enum) {
                if ((resolved.enum as unknown[]).every((value) => typeof value === "string")) {
                    const enumType = getOrCreateGoEnum(typeName, resolved.enum as string[], ctx, resolved.description, getEnumValueDescriptions(resolved), isSchemaDeprecated(resolved), isSchemaExperimental(resolved));
                    return isRequired ? enumType : `*${enumType}`;
                }
                if (resolved.enum.length === 1) {
                    return resolveGoPropertyType(schemaForConstValue(resolved.enum[0]), parentTypeName, jsonPropName, isRequired, ctx);
                }
                return "any";
            }
            if (isNamedGoObjectSchema(resolved)) {
                emitGoStruct(typeName, resolved, ctx);
                return isRequired ? typeName : `*${typeName}`;
            }
            const resolvedUnion = resolved as JSONSchema7;
            if (resolvedUnion.anyOf || resolvedUnion.oneOf) {
                emitGoRpcDefinition(refTypeName(propSchema.$ref, ctx.definitions), resolved, ctx);
                if (goDiscriminatedUnionInfoForType(typeName, ctx)) {
                    return typeName;
                }
                return isRequired ? typeName : `*${typeName}`;
            }
            return resolveGoPropertyType(resolved, parentTypeName, jsonPropName, isRequired, ctx);
        }
        // Fallback: use the type name directly
        return isRequired ? typeName : `*${typeName}`;
    }

    // Handle anyOf
    if (propSchema.anyOf) {
        const nullableInnerSchema = getNullableInner(propSchema);
        if (nullableInnerSchema) {
            // anyOf [T, null/{not:{}}] → nullable T
            const innerType = resolveGoPropertyType(nullableInnerSchema, parentTypeName, jsonPropName, true, ctx);
            // Pointer-wrap if not already a pointer, slice, or map
            return goTypeWithOptionalPointer(innerType, ctx);
        }
        const nonNull = (propSchema.anyOf as JSONSchema7[]).filter((s) => s.type !== "null");
        const hasNull = (propSchema.anyOf as JSONSchema7[]).some((s) => s.type === "null");

        if (nonNull.length === 1) {
            // anyOf [T, null] → nullable T
            const innerType = resolveGoPropertyType(nonNull[0], parentTypeName, jsonPropName, true, ctx);
            if (isRequired && !hasNull) return innerType;