Function collectGoSharedSessionEventAliasNames

scripts/codegen/go.ts:3514–3559

(
    sharedDefinitionNames: Iterable<string>,
    apiSchema: ApiSchema
)

}

function collectGoSharedSessionEventAliasNames(
    sharedDefinitionNames: Iterable<string>,
    apiSchema: ApiSchema
): { typeNames: string[]; constNames: string[] } {
    const apiDefinitions = collectDefinitionCollections(apiSchema as Record<string, unknown>);
    const definitions = { ...apiDefinitions.$defs, ...apiDefinitions.definitions };
    const typeNames = new Set<string>();
    const constNames = new Set<string>();

    for (const definitionName of sharedDefinitionNames) {
        const typeName = toGoFieldName(definitionName);
        typeNames.add(typeName);

        const definition = definitions[definitionName];
        if (!definition || typeof definition !== "object" || Array.isArray(definition)) continue;

        const schema = definition as JSONSchema7;
        const values = isStringEnumDefinition(schema)
            ? schema.enum
            : typeof schema.const === "string"
                ? [schema.const]
                : undefined;
        for (const value of values ?? []) {
            constNames.add(`${typeName}${goEnumConstSuffix(value)}`);
        }

        // Detect anyOf unions with a string-const discriminator property. The
        // api/rpc generator synthesizes an enum (named `<TypeName><DiscProp>`)
        // and per-variant consts for these (e.g. `Attachment` → `AttachmentType`
        // + `AttachmentTypeFile`, ...). They aren't top-level $defs, so we have
        // to surface them explicitly here so the public `copilot` alias file
        // re-exports them alongside the union and its variant structs.
        const synthesized = collectGoSharedAnyOfDiscriminatorAliasNames(typeName, schema, definitions);
        if (synthesized) {
            typeNames.add(synthesized.enumName);
            for (const constName of synthesized.constNames) {
                constNames.add(constName);
            }
        }
    }

    return {
        typeNames: [...typeNames].sort(compareGoTypeNames),
        constNames: [...constNames].sort(compareGoTypeNames),
    };
}

/**
 * For a shared definition that is an `anyOf` discriminated union with a