Here is my proposed solution, although @TobiasS's solution also works effectively. It may not be the most visually appealing, but it was intentionally designed to be more "extensible".

type InputTypeMap = {
    text: string;
    textarea: string;
    daterange: [number, number];
    checkbox: boolean;
};

type AddUndefinedIfDependent<T, F extends FormField> = "dependencies" extends keyof F ? T | undefined : T;

type DataFrom<F extends FormField[]> = {
    [K in F[number]["key"]]:
        Extract<F[number], { key: K }> extends infer Field extends FormField
            ? Field["type"] extends keyof InputTypeMap
                ? AddUndefinedIfDependent<InputTypeMap[Field["type"]], Field>
                : Field["type"] extends "object"
                    ? "fields" extends keyof Field
                        ? Field["fields"] extends FormField[]
                            ? AddUndefinedIfDependent<DataFrom<Field["fields"]>, Field>
                            : never
                        : never
                    : Field["type"] extends "array"
                        ? "fields" extends keyof Field
                            ? Field["fields"] extends FormField[]
                                ? AddUndefinedIfDependent<DataFrom<Field["fields"]>[], Field>
                                : never
                            : never
                        : Field["type"] extends "select"
                            ? "options" extends keyof Field
                                ? Field["options"] extends { value: any }[]
                                    ? "fieldParams" extends keyof Field
                                        ? Field["fieldParams"] extends { multiple: true }
                                            ? AddUndefinedIfDependent<Field["options"][number]["value"][], Field>
                                            : AddUndefinedIfDependent<Field["options"][number]["value"], Field>
                                        : never
                                    : never
                                : never
                            : never
            : never;
} extends infer O ? { [K in keyof O]: O[K] } : never;

The essence of this logic is to determine the correct type output. What sets it apart is the utilization of another type for mapping input types to the output type. For instance, daterange translates to [number, number] in InputTypeMap. This feature facilitates the addition of more input types if required. Note that types influenced by other elements in the field should be included in the DataFrom type.

If you are curious about this particular line:

} extends infer O ? { [K in keyof O]: O[K] } : never;

This line simplifies the output type to avoid displaying DataFrom<...> in tooltips.

Below is an example of how you can define your function:

function createForm<I extends FormInit>(
    init: Narrow<I>
): Promise<{
    isCompleted: false;
    formData: undefined;
} | { // using discriminated union so that when isCompleted is false, formData is undefined
    isCompleted: true;
    formData: DataFrom<I["fields"]>;
}> {

Playground

Here is a possible solution to illustrate the concept:

async function generateForm<T extends string>(input: {
  fields: { 
    key: T,
    label: string,
    type: string,
    required: boolean,
    size?: number
  }[]
}): Promise<{ formData: { [K in T]: string }, status: any }> {
  return {} as any
}

In this scenario, the 'key' field contents are stored within the generic type 'T', which can be utilized later to construct a mapped type for the result.

If the structure becomes more intricate, a revamp with additional/varied generic types may be necessary.

Run code sample here

UPDATE:

Below is a potential solution tailored to your revised specifications.

type FormDataStructure<N> = {
  key: N
  label: string
  type: N
  mandatory?: boolean
  size?: number
  details?: {
    multipleValues: boolean,
    editable: boolean,
  },
  conditions?: (...args: any) => any
  subfields?: FormDataStructure<N>[]
}

The definition of 'FormDataStructure' outlines the setup of the argument for 'generateForm'. Properties not pertinent to the query have been omitted.

type DetermineFormDataType<K extends FormDataStructure<any>> =  
  K["type"] extends "checkbox"
    ? boolean
    : K["type"] extends "object"
      ? K["subfields"] extends infer U extends FormDataStructure<any>[]
        ? DataReturnType<U[number]>
        : never
      : K["type"] extends "select"
        ? K["details"] extends { multipleValues: true }
          ? string[]
          : string
        : K["type"] extends "array"
          ? K["subfields"] extends infer U extends FormDataStructure<any>[]
            ? DataReturnType<U[number]>[]
            : never
          : K["type"] extends "daterange"
            ? [string, string]
            : string

'DetermineFormDataType' examines an object from the 'subfields' and determines its type based on the 'type' property.

type DataReturnType<T extends FormDataStructure<any>> = UnionToIntersection<{
  [K in T as K["conditions"] extends (...args: any) => any ? never : K["key"]]: 
    DetermineFormDataType<K>
} | {
  [K in T as K["conditions"] extends (...args: any) => any ? K["key"] : never]?: 
    DetermineFormDataType<K>
}>

'DataReturnType' recursively traverses the 'subfields' and decides which properties should be optional.

type UnionToIntersection<U> = 
  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never

type RecursiveExpansion<T> = T extends object
  ? T extends infer O ? { [K in keyof O]: RecursiveExpansion<O[K]> } : never
  : T;

type Narrowable = string | number | boolean | symbol | object | undefined | void | null | {};

async function generateForm<T extends FormDataStructure<N>, N extends Narrowable>(input: {
  fields: T[]
}): Promise<{ status: any, formData: RecursiveExpansion<DataReturnType<T>> } > {
  return {} as any
}

Test playground scenario here