type keyword = "foo" | "bar" | "baz"

type validateString<s> = s extends keyword
    ? s
    : s extends `${infer left extends keyword}|${infer right}`
    ? right extends keyword
        ? s
        : `${left}|${keyword}`
    : keyword

type isUnknown<t> = unknown extends t
    ? [t] extends [{}]
        ? false
        : true
    : false

type validate<def> = def extends string
    ? validateString<def>
    : isUnknown<def> extends true
    ? keyword
    : {
          [k in keyof def]: validate<def[k]>
      }

const parse = <def>(def: validate<def>) => def

// typing "f" autocompletes to "foo"
const shallowKeyword = parse("foo")

// typing "foo|b" does not autocomplete but yields the following type error if left incomplete:
// Argument of type '"foo|b"' is not assignable to parameter of type '"foo|foo" | "foo|bar" | "foo|baz"'
// @ts-expect-error
const shallowExpression = parse("foo|b")

// typing "f" autocompletes to "foo"
const deepKeyword = parse({ k: "foo" })

// typing "foo|b" autocompletes to "foo|bar" | "foo|baz"
const deepExpression = parse({ k: "foo|bar" })