Typescript enum parameter with multiple options and chaining

In order for your plan to work you need to make sure that all the foreground and background color values are distinct strings at runtime. That looks to be the case for your normal colors, but Reset is the same for both. I'm going to move Reset out of the enums. For simplicity, here's the data I'm using:

enum FgColors {
    Red = "[fgRed]",
    Green = "[fgGrn]",
    Blue = "[fgBlu]"
}
enum BgColors {
    Red = "[bgRed]",
    Green = "[bgGrn]",
    Blue = "[bgBlu]"
}
const Reset = "[reset]";

You can't use typeof at runtime to determine if a color is FgColors or BgColors because they will just be strings, and typeof color will be "string". Instead you will have to look for the particular string inside the values of the FgColors enum object, like this:

function isFgColor(val: FgColors | BgColors): val is FgColors {
    return (Object.values(FgColors) as ReadonlyArray<typeof val>).includes(val);
}

Then your Colorize() function could possibly be implemented like this:

function Colorize<T extends FgColors | BgColors>(color1: T) {
    return {
        and(color2: T extends FgColors ? BgColors : FgColors) {
            return {
                on(text: string) {
                    const [fg, bg] = isFgColor(color1) ? [color1, color2] : [color2, color1];
                    return `${bg}${fg}${text}${Reset}`;
                }
            }
        }
    }
};

By having the function be generic, we can make the compiler try to enforce that the call to and() should pick a color from the other enum. The generic type T corresponds to the first color, and T extends FgColors ? BgColors : FgColors is a conditional type that says "if T is a FgColors, then we want a BgColors; otherwise we want a FgColors. This isn't strictly what you asked for, but without it, you run the risk of allowing two foregrounds or two backgrounds.

Notice how the Colorize() function is not making a class or using this; instead, it returns an object whose single and property is a function that returns an object whose single on property is a function that returns a string.

Let's test it:

const test = Colorize(BgColors.Green).and(FgColors.Blue).on("hey");
console.log(test); // [bgGrn][fgBlu]hey[reset]
const test2 = Colorize(FgColors.Blue).and(BgColors.Green).on("you");
console.log(test2); // [bgGrn][fgBlu]you[reset]

That looks right, I think. And let's make sure you can't do it wrong:

const bad = Colorize(FgColors.Red).and(FgColors.Red); // error!
// ----------------------------------> ~~~~~~~~~~~~
// Argument of type 'FgColors.Red' is not assignable to parameter of type 'BgColors'

Looks good.

Okay, hope that helps; good luck!

Playground link to code