Typescript: Make all properties optional unless explicited when using a literal type

I am trying to type the search endpoint of Spotify's API.

In their documentation, it says that the return payload is

export enum ResourceType {
  Album = 'album',
  Artist = 'artist',
  Playlist = 'playlist',
  Track = 'track',
  Show = 'show',
  Episode = 'episode',
  Audiobook = 'audiobook',

  Albums = 'albums',
  Artists = 'artists',
  Playlists = 'playlists',
  Tracks = 'tracks',
  Shows = 'shows',
  Episodes = 'episodes',
  Audiobooks = 'audiobooks',
}

interface ResourceTypeToResultKey {
  [ResourceType.Album]: ResourceType.Albums
  [ResourceType.Artist]: ResourceType.Artists
  [ResourceType.Track]: ResourceType.Tracks
  [ResourceType.Playlist]: ResourceType.Playlists
  [ResourceType.Show]: ResourceType.Shows
  [ResourceType.Episode]: ResourceType.Episodes
  [ResourceType.Audiobook]: ResourceType.Audiobooks
}

// Basically translates to -> Make every property possibly undefined
type SearchResults = {
  [K in SearchType as ResourceTypeToResultKey[K]]?: unknown // Don't pay attention to the value, I got it fine.
}

However, the documentation suggests that the real typing of the response is: "we will only return the keys that you asked for".

That translates to: if the list is a literal type, we can narrow the typing and make the properties required.

Now my issue is: if the list is not a literal type, how can we force the response to still return the whole type with all properties marked optional ?

Basically, what I'm trying to do is:

declare const search: <T extends SearchType>(types: T[]) => Required<Pick<SearchResults, ResourceTypeToResultKey[T]>>
declare const types: SearchType[]
const result = search(types)
// the given type should be `SearchResults` (all properties marked optional)
result.tracks // Not ok, should be optional as it can't be determined for sure

const result2 = search([ResourceType.Track])
// the given type should be `{ tracks: unknown }`
result2.tracks // ok

Is this even feasible ?

Here is what my attempt: playground

First of all, let's see how we can check whether the array is a tuple (literal type) or not.

The difference is in the length of the array type. In the case of tuples, it is a finite number. Let's see something first:

type Case1 = 1 extends number ? true : false
//   ^? true

type Case2 = number extends 1 ? true : false
//   ^? false

1 extends number since it is a sub-type of number, but not the reverse.

Examples with arrays / tuples:

type Case1 = [1, 2, 3]["length"];
//   ^? 3

type Case2 = (readonly [1, 2, 3])["length"];
//   ^? 3

type Case3 = number[]["length"];
//   ^? number

type Case4 = (readonly number[])["length"];
//   ^? number

Thus, we can conclude that if the length of the array is a finite number then it is a tuple, otherwise it is an array, the exact length of which we can't determine. Let's write a utility type for that:

type IsTuple<T extends readonly unknown[]> = number extends T['length'] ? false : true

Note that we are using readonly modifier to accept readonly arrays/tuples as well, since readonly version of an array / tuple is a super type of that array:

type Case1 = readonly number[] extends number[] ? true : false;
//   ^? false

type Case2 = number[] extends readonly number[] ? true : false;
//   ^? true

In the search, we must modify the generic parameter T to be constrained by readonly SearchType[] instead of SearchType. Also, we need to turn T into const type parameter to prevent the compiler from widening array types to an array of primitives. Note that const type parameters were added in Typescript >= 5.0 and if you have the lower version you will need to use const assertion when you pass the array into function. We need these changes to be able to use IsTuple, and the reason to add readonly was already mentioned previously:

declare const search: <const T extends readonly SearchType[]>(types: T) => ToBeDefined

We are going to indexed access to get the elements of T:

T[number]

To avoid code repetition we are going to store the result of the pick in the inferred parameter R using the infer keyword:

Pick<SearchResults, ResourceTypeToResultKey[T[number]]> extends infer R 
 ? DoSomething
 : never // in theory, never will be reached

Next, we are going to see if T is a tuple, and if yes we will make the R non-optional, otherwise return it as it is:

Pick<SearchResults, ResourceTypeToResultKey[T[number]]> extends infer R
  ? IsTuple<T> extends false
    ? R
    : Required<R>
  : never;

And we are good to go:

declare const search: <const T extends readonly SearchType[]>(
  types: T
) => Pick<SearchResults, ResourceTypeToResultKey[T[number]]> extends infer R
  ? IsTuple<T> extends false
    ? R
    : Required<R>
  : never;

Testing:

declare const types: SearchType[];
const result = search(types);
result.tracks; // (property) tracks?: unknown

const result2 = search([ResourceType.Track]);

result2.tracks; // (property) tracks: unknown

Link to Playground