The problem is a couple of things. I started by changing children: Array<any> to children: React.ReactNode. You already have a check in there to narrow the type from ReactNode to ReactElement. The trick was 1. using the generic type arguments in isValidElement and 2. using a new variable with a type assignment on it elementChild rather than dealing with and mutating the child argument. EnrichedChildren may need to be updated to match your use case.

interface EnrichedChildren {
  onChange(): void
  selectedValue: string
  name: string
  children?: React.ReactNode
}

enrichRadioElements = (children: React.ReactNode, name: string): any =>
  React.Children.map(children, child => {
    if (!React.isValidElement<EnrichedChildren>(child)) {
      return child
    }

    let elementChild: React.ReactElement<EnrichedChildren> = child
    if (child.props.children) {
      elementChild = React.cloneElement<EnrichedChildren>(elementChild, {
        children: this.enrichRadioElements(elementChild.props.children, name),
      })
    }

    if (elementChild.type === 'Radio') {
      return React.cloneElement(elementChild, {
        onChange: () => {},
        selectedValue: 'value',
        name: name,
      })
    } else {
      return elementChild
    }
  })

In short, the ReactNode type is a union type for a: ReactChild | ReactFragment | ReactPortal | boolean | null | undefined.

The type error is telling you what's wrong: You're assuming the child is always going to be defined AND is an JSXElement/ReactElement with props with an array of children that has a props property with a defined id prop.

VSCode, or rather the Typescript language server, is displaying an error stating that there's no way for it to know if a child meets these requirements because you haven't put up any type guards for them. Therefore, you can't access properties on this child parameter when it can be null, undefined, boolean, string, number, and so on.

I'm not sure what you're trying to accomplish with your code above, but you have to let Typescript know that only a child that isValidElement can be accessed/manipulated/changed; otherwise, you're going to run into JavaScript type errors (i.e., "Can't read properties of null/undefined (reading props/children/id)"). On that note, you can use optional chaining to access conditional properties on an object type.

Demo:

Using any should generally be avoided as you're losing the type info.

Instead use React.ReactElement<P> in the function parameter type:

React.Children.map(this.props.children, (child: React.ReactElement<ChildPropTypes>) => child.props.bar)