How generate dotted-object-path type from Object?

[fullheart]

Hi together

How I can generate all paths of an object as String literal's with dot separator with ts-toolbelt's Object.Paths and String.Join as Union type like this?

// Object
const obj = {
   a: 'abc',
   b: 'def',
   c: {
      c1: 'c1',
      100: 'c2',
   }
}
// Type
type dottedType = 'a' | 'b' | 'c.c1' | 'c.100'

On stackoverflow.com I found this solution (https://stackoverflow.com/a/58436959) without ts-toolbelt:

type Prev = [
  never,
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  11,
  12,
  13,
  14,
  15,
  16,
  17,
  18,
  19,
  20,
  ...0[]
]

type Join<K, P> = K extends string | number
  ? P extends string | number
    ? `${K}${"" extends P ? "" : "."}${P}`
    : never
  : never

type Leaves<T, D extends number = 10> = [D] extends [never]
  ? never
  : T extends object
  ? {
      [K in keyof T]-?: Join<K, Leaves<T[K], Prev[D]>>
    }[keyof T]
  : ""

// Object
const obj = {
   a: 'abc',
   b: 'def',
   c: {
      c1: 'c1',
      100: 'c2',
   }
}
// Type
type dottedType = Leaves<typeof obj>
// type dottedType =  'a' | 'b' | 'c.c1' | 'c.100'

Question: How I can simplify this Code with ts-toolbelt?

Thank you in advance!

[fullheart]

On stackoverflow.com I get "almost" the complete answer: https://stackoverflow.com/a/71406876/18416404

Only converting this solution to a one-line type, throws an errors:

import { Object, String, List } from "ts-toolbelt"

export type DottedObjectPaths<T> = String.Join<List.Required<Object.Paths<T>>, ".">

Error:

Type 'Cast<{ [K in keyof Paths<T, []>]-?: Paths<T, []>[K]; }, List<any>>' does not satisfy the constraint 'List<Literal>'.
  Type 'List<any> | { [K in keyof Paths<T, []>]-?: Paths<T, []>[K]; }' is not assignable to type 'readonly Literal[]'.
    Type '{ [K in keyof Paths<T, []>]-?: Paths<T, []>[K]; }' is not assignable to type 'readonly Literal[]'.
      Types of property 'concat' are incompatible.
        Type 'Paths<T, []>["concat"]' is not assignable to type '{ (...items: ConcatArray<Literal>[]): Literal[]; (...items: (Literal | ConcatArray<Literal>)[]): Literal[]; }'.
          Type '{ (...items: ConcatArray<Key>[]): Key[]; (...items: (Key | ConcatArray<Key>)[]): Key[]; }' is not assignable to type '{ (...items: ConcatArray<Literal>[]): Literal[]; (...items: (Literal | ConcatArray<Literal>)[]): Literal[]; }'.
            Types of parameters 'items' and 'items' are incompatible.
              Type 'ConcatArray<Literal>' is not assignable to type 'ConcatArray<Key>'.
                Type 'Literal' is not assignable to type 'Key'.
                  Type 'bigint' is not assignable to type 'Key'.

Thank you for help