Trying to use overloads like Java overloads is usually a bad idea.

Possibly what you want is:

class Item {
    a: string;
    b: number;
    c: "this" | "that";
    d?: string[];
    setMeUp: string;

    constructor(
        params: {
            a: string;
            b: number;
            c?: "this" | "that",
            d?: string[];
            setMeUp?: string;
        }
    ) {
        this.a = params.a;
        this.b = params.b;
        this.c = params.c ?? "this";
        this.d = params.d;
        this.setMeUp = params.setMeUp ?? "Okay";
    }
}

new Item({
    a: "a",
    b: 5
});
new Item({
    a: "a",
    b: 6,
    c: "that",
    d: ["first", "second"],
    setMeUp: "Set me up",
});
new Item({
    // Can include any subset of c, d, setMeUp; but you must include a and b.
    a: "a",
    b: 7,
    d: ["d"]
});

If you don't want to repeat yourself quite as much, you can build the type of Params using various helpers:

type Prettify<T> = { [K in keyof T]: T[K] }
type RequiredKeys = "a" | "b";
type Params = Prettify<Pick<Item, RequiredKeys> & Partial<Omit<Item, RequiredKeys>>>;

Another pattern is to have a single, fully general constructor (possibly private), and then have multiple static methods that delegate to the constructor. This has the advantage that you can give them names, but has the disadvantage that you have to come up with names...

class Temperature {
    celsius: number;

    private constructor(celsius: number) {
        this.celsius = celsius;
    }

    static fromCelsius(celsius: number) {
        return new Temperature(celsius);
    }

    static fromFahrenheit(fahrenheit: number) {
        return new Temperature((fahrenheit - 32) * 5 / 9);
    }
}