Referindo-se a um tipo de objeto dentro do próprio objeto

Você pode criar um auxiliar de tipo recursivo que permite obter essa inferência de tipo dinamicamente.

type Config<TChildren = Record<string, never>> = {
  name: string;
  value: number;
  children?: TChildren;
  visibilityFn?: (children: TChildren) => boolean;
};

// Recursive definition for nested configurations
type ConfigTree = {
  [key: string]: Config<ConfigTree>;
};

const config: Config<ConfigTree> = {
  name: 'config',
  value: 1,
  children: {
    one: {
      name: 'one',
      value: 1,
      visibilityFn: (children) => children.two.value > 3,
    },
    two: {
      name: 'two',
      value: 2,
    },
  },
};

// Type inference works here
if (config.children) {
  const visible = config.children.one.visibilityFn?.(config.children);
  console.log(visible);
}

Geralmente, você não pode se referir a typeof xdentro da definição para o valor xsem entrar em conflito com os avisos de circularidade do TypeScript. Na verdade, o que você precisa fazer é dar Config<T>uma definição genérica recursiva adequada para que ela possa realmente representar o tipo que você precisa automaticamente pretende transmitir, onde em cada nível da árvore, o visibilityFnparâmetro de retorno de chamada do método opcional corresponde ao tipo da childrenpropriedade do pai daquele nível. Algo assim:

type Config<T, TP = {}> = {
    name: string,
    value: number,
    children?: ConfigChildren<T>
    visibilityFn?: (children: ConfigChildren<TP>) => boolean
}

type ConfigChildren<T> = { [K in keyof T]: Config<T[K], T> }

Aqui TPestá o tipo pai, que para o nível superior deve ser apenas o objeto de tipo vazio (é por isso que escolhi isso como o argumento de tipo padrão para TP). Então, se childrenfor do tipo ConfigChildren<T>, então visibilityFnrecebe um parâmetro do tipo ConfigChildren<TP>. Então ConfigChildrené apenas um tipo mapeado onde cada propriedade está Config<T[K], T>(já que no próximo nível abaixo, Tse torna o pai da T[K]propriedade).

Agora você não pode usar o satisfiesoperador diretamente porque não pode facilmente nomear o tipo configque ele deve satisfazer sem se referir a si mesmo. Ou seja, você precisaria escrever satisfies Config<{one: any, two: { three: any} }>ou algo assim, e principalmente anula o propósito do que você está fazendo. Se você estivesse feliz escrevendo esse tipo de propriedade como um argumento de tipo, então você teria apenas anotado seu tipo de parâmetro explicitamente em vez de tentar escrever typeof config.children.

Então, vamos abandonar isso satisfiesem favor de uma função auxiliar genérica que, com sorte, infere esse tipo de argumento para você:

const asConfig = <T,>(c: Config<T>) => c;

E agora você pode chamá-lo em seu literal de objeto:

const config = asConfig({
    name: 'config',
    value: 1,
    children: ({
        one: {
            name: 'one',
            value: 1,
            children: {},
            visibilityFn: (children) => (children.two.children?.three.value ?? 0) > 3
            //             ^? (parameter) children: ConfigChildren<
            //                  {  one: unknown; two: { three: unknown; };}>
        },
        two: {
            name: 'two',
            value: 2,
            children: ({
                three: {
                    name: 'three',
                    value: 3,
                    children: {}
                }
            })
        },
    }),
})
/* const config: Config<{
    one: unknown;
    two: {
        three: unknown;
    };
}, {}> */

Aqui, o argumento de tipo Té inferido como {one: unknown; two: {three: unknown}}, e, portanto, dentro de config.one.visibilityFn, o childrenparâmetro é contextualmente tipado como ConfigChildren<T>para isso T, e, portanto, sabe-se que children.two.children, se existir, tem uma threepropriedade. (Observe que a parte "se existir" é porque childrené definido como uma propriedade opcional de config. Se você precisar de algo mais específico para que o TypeScript saiba quando ele aparece e não aparece, você precisará fazer uma refatoração. Mas os detalhes de como esse tipo recursivo deve ser ajustado para seu caso de uso estão fora do escopo aqui.)

Isso funciona até certo ponto, mas esteja ciente de que o TypeScript não tem a capacidade de inferir tipos arbitrariamente complicados. Pode ser que em alguma profundidade da sua árvore você precise envolver algo em outra asConfig()chamada para que os níveis mais baixos sejam inferidos separadamente dos superiores. Ou você pode se ver tendo que anotar parâmetros de tipo que você realmente prefere que o TypeScript infira para você. Isso pode acontecer, especialmente quando genéricos e tipagem contextual precisam ocorrer simultaneamente ou em alguma ordem específica. Há uma solicitação de recurso em microsoft/TypeScript#47599 para melhorar esse tipo de inferência, mas sempre haverá casos em que isso simplesmente não pode acontecer. Se você se deparar com isso, será muito melhor apenas escrever o tipo de que precisa em vez de tentar forçar o TypeScript a fazer coisas que ele não consegue fazer bem.

Link do playground para o código