How to infer or to deduce the return type from an argument in typescript

I have a type that is deductible from one field of the object.

And I wrote this function that takes the zoneType and returns the associate zone.

But at the end, and on each call I get : MyType1 | MyType2 | MyType3 and not the associated type. This type is actually deductible from the argument, since the switch case can easily find the type.

We are talking about geojson btw.

I was wondering trying overloading, but typescript does not allow having duplicated functions.
Also, infer, but it looks "huge" for something that can be guessed by TS itself?

I will appreciate your help.

Thanks !

type MyType1 = "geojson.Feature<geojson.MultiPolygon>";
type MyType2 = "geojson.Feature<geojson.Polygon>";
type MyType3 = "geojson.FeatureCollection<geojson.Polygon>";

export type ZoneGeojson = MyType1 | MyType2 | MyType3;

type InternalZone = {
  id: number;
  zone: ZoneGeojson | null;
  zone_type: ZoneZoneType;
};

export interface Zone1 extends InternalZone {
  zone_type: ZoneZoneType.Type1 | ZoneZoneType.Type2;
  zone: MyType1 | null;
}

export interface Zone2 extends InternalZone {
  zone_type: ZoneZoneType.Type3;
  zone: MyType1 | null;
}

export interface Zone3 extends InternalZone {
  zone_type: ZoneZoneType.Type4;
  zone: MyType1 | null;
}

export const exportZone = (
  zoneType: ZoneZoneType,
  zone: FeatureCollection<Polygon>,
) => {
  switch (zoneType) {
    case ZoneZoneType.Type1:
    case ZoneZoneType.Type2:
      return zone1.zoneGeojsonFactory.exportZoneEdition(zone);
    case ZoneZoneType.Type3:
      return zone2.zoneGeojsonFactory.exportZoneEdition(zone);
    case ZoneZoneType.Type4:
      return zone3.zoneGeojsonFactory.exportZoneEdition(zone);
    default:
      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
      throw new Error(`Unknown zone type ${zoneType ?? '[undefined]'}`);
  }
};

This is some specific case of return type based on parameter

Applied to your case :

type ObjectType<T> = 
  T extends ZoneZoneType.Type1 ? Zone1 :
  T extends ZoneZoneType.Type2 ? Zone1 :
  T extends ZoneZoneType.Type3 ? Zone2 :
  T extends ZoneZoneType.Type4 ? Zone3 :
never;

export const exportZoneEditionGeojson = <T extends ZoneZoneType>(
  zoneType: T,
  zoneEditionGeojson: FeatureCollection<Polygon>,
): ObjectType<T> => {
  switch (zoneType) {
    case ZoneZoneType.Type1:
    case ZoneZoneType.Type2:
      return zone1.zoneGeojsonFactory
        .exportZoneEdition(zoneEditionGeojson) as ObjectType<T>;
    case ZoneZoneType.Type3:
      return zone2.zoneGeojsonFactory
        .exportZoneEdition(zoneEditionGeojson) as ObjectType<T>;
    case ZoneZoneType.Type4:
      return zone3.zoneGeojsonFactory
        .exportZoneEdition(zoneEditionGeojson) as ObjectType<T>;
    default:
      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
      throw new Error(`Unknown zone type ${zoneType}`);
  }
};

You could use a map of inputs to output types, and a function overload.

I have added a definition for ZoneZoneType and the zoneX functions and then trimmed your code down to a Minimal Reproducible Example. Although, for this, even the second parameter is actually unnecessary.

enum ZoneZoneType {
  Type1,
  Type2,
  Type3,
  Type4,
}

const zone1 = (input: string) => "zone1" as const;
const zone2 = (input: string) => "zone2" as const;
const zone3 = (input: string) => "zone3" as const;

type ResultMap = {
  [ZoneZoneType.Type1]: ReturnType<typeof zone1>;
  [ZoneZoneType.Type2]: ReturnType<typeof zone1>;
  [ZoneZoneType.Type3]: ReturnType<typeof zone2>;
  [ZoneZoneType.Type4]: ReturnType<typeof zone3>;
};

export function exportZone<T extends ZoneZoneType>(
  zoneType: T,
  zone: string
): ResultMap[T];
export function exportZone(zoneType: ZoneZoneType, zone: string) {
  switch (zoneType) {
    case ZoneZoneType.Type1:
    case ZoneZoneType.Type2:
      return zone1(zone);
    case ZoneZoneType.Type3:
      return zone2(zone);
    case ZoneZoneType.Type4:
      return zone3(zone);
    default:
      throw new Error(`Unknown zone type ${zoneType ?? "[undefined]"}`);
  }
}

const res1 = exportZone(ZoneZoneType.Type1, "foo");
//     ^? const res1: "zone1"
const res2 = exportZone(ZoneZoneType.Type2, "foo");
//     ^? const res2: "zone1"
const res3 = exportZone(ZoneZoneType.Type3, "foo");
//     ^? const res3: "zone2"
const res4 = exportZone(ZoneZoneType.Type4, "foo");
//     ^? const res4: "zone3"

TS Playground

The function implementation is as you had. However, the signature the caller sees has the return type determined from the input, by indexing into the new ResultMap type.

This does not enforce actually returning the specified type, so it's up to you to ensure that the map and the returns are correct.
The answer by @Neiluj uses type assertions on the returns, so it is also unsafe.
Pick what works for your case.

Overloads are unsafe in general, so do be careful on your quest...

The advantages I see over the implementation using conditional types:

• the simpler syntax of the mapping type;
• record-based mapping types work better than conditional types in more complex scenarios;
• ease of switching to utilizing the "dependent-type-like functions" feature, should it be implemented.

Someone like @jcalz will likely be able to comment further on the differences.

See TS #33014 ("Suggestion for Dependent-Type-Like Functions: Conservative Narrowing of Generic Indexed Access Result Type") for the request to add proper support for this.
See @jcalz's answer to "TypeScript generics work when you call it but not in the function body?" for more info on workarounds for the general problem of defining parameters using generic type parameters.