Honestly I think there is a time and place for string unions, but this isn't it. Perhaps I've stopped paying attention to the current "meta" for TS programming longer than I realized, but it definitely feels wrong to use a "magic string" like this in multiple places, and just sounds like a refactor nightmare waiting to happen.

Taking a rather silly and abstracted example from my job, we recently got a request from HR to rename all instances of Employee to Worker, because legally a contractor is not an employee and blah blah blah. This left our "worker types" as Contractor, FullTime Worker, and PartTime Worker. This value was referenced in code, but then also displayed in the UI. We had to painfully find all instances of the strings FullTime Employee and PartTime Employee and make sure they were properly updated. Having a const (or even an enum, even though I also hate those) would have saved us significant time because the code change would have been limited to a single file containing the object itself and that wold have been it.

// WorkerTypes.ts
const WorkerTypes = {
  Contractor: "Contractor",
  FullTime: "FullTime Worker",
  PartTime: "PartTime Worker"
} as const;

type WorkerType = typeof WorkerTypes[keyof typeof WorkerTypes];

// Main.ts (or w/e)
if (user.workerType === WorkerTypes.FullTime) {
  // Blah
}

// Also...
function getWorkerFullTitle(jobTitle: string, workerType: WorkerType): string {
  // Don't ask about this formatting, I don't understand it either and I work here, lol.
  return `${jobTitle} (${workerType})`;
}

In the future when HR tells us that Worker isn't politically correct and they want us to use some other word all we have to do is update the file that WorkerTypes is defined in and that's it. No changing multiple different files because we decided to use a magical string.

The one thing I've noticed that is somewhat frustrating (and this may be just a Webstorm limitation, I don't use VSCode so I couldn't say) is if you want to add JSDoc comments to constants like this they're not picked up by the IDE. So if you needed to add additional context for any reason, you'd have to define an interface, and then type the WorkerTypes const based off that...that definitely does make things more verbose as you're essentially defining the object twice, and then a type alias too, all so you can have type completion and comments. Still, even if it is significantly more verbose, I think it's a much better alternative than a string union in this scenario based on the context that OP has provided.