def METHOD_NAME(
    self, parent_field_identifier: str, declarative_component: Mapping[str, Any], parent_parameters: Mapping[str, Any]
) -> Mapping[str, Any]:
    """
    Recursively transforms the specified declarative component and subcomponents to propagate parameters and insert the
    default component type if it was not already present. The resulting transformed components are a deep copy of the input
    components, not an in-place transformation.
    :param declarative_component: The current component that is having type and parameters added
    :param parent_field_identifier: The name of the field of the current component coming from the parent component
    :param parent_parameters: The parameters set on parent components defined before the current component
    :return: A deep copy of the transformed component with types and parameters persisted to it
    """
    propagated_component = dict(copy.deepcopy(declarative_component))
    if "type" not in propagated_component:
        # If the component has class_name we assume that this is a reference to a custom component. This is a slight change to
        # existing behavior because we originally allowed for either class or type to be specified. After the pydantic migration,
        # class_name will only be a valid field on custom components and this change reflects that. I checked, and we currently
        # have no low-code connectors that use class_name except for custom components.
        if "class_name" in propagated_component:
            found_type = CUSTOM_COMPONENTS_MAPPING.get(parent_field_identifier)
        else:
            found_type = DEFAULT_MODEL_TYPES.get(parent_field_identifier)
        if found_type:
            propagated_component["type"] = found_type
    # When there is no resolved type, we're not processing a component (likely a regular object) and don't need to propagate parameters
    if "type" not in propagated_component:
        return propagated_component
    # Combines parameters defined at the current level with parameters from parent components. Parameters at the current
    # level take precedence
    current_parameters = dict(copy.deepcopy(parent_parameters))
    component_parameters = propagated_component.pop(PARAMETERS_STR, {})
    current_parameters = {**current_parameters, **component_parameters}
    # Parameters should be applied to the current component fields with the existing field taking precedence over parameters if
    # both exist
    for parameter_key, parameter_value in current_parameters.items():
        propagated_component[parameter_key] = propagated_component.get(parameter_key) or parameter_value
    for field_name, field_value in propagated_component.items():
        if isinstance(field_value, dict):
            # We exclude propagating a parameter that matches the current field name because that would result in an infinite cycle
            excluded_parameter = current_parameters.pop(field_name, None)
            parent_type_field_identifier = f"{propagated_component.get('type')}.{field_name}"
            propagated_component[field_name] = self.METHOD_NAME(
                parent_type_field_identifier, field_value, current_parameters
            )
            if excluded_parameter:
                current_parameters[field_name] = excluded_parameter
        elif isinstance(field_value, typing.List):
            # We exclude propagating a parameter that matches the current field name because that would result in an infinite cycle
            excluded_parameter = current_parameters.pop(field_name, None)
            for i, element in enumerate(field_value):
                if isinstance(element, dict):
                    parent_type_field_identifier = f"{propagated_component.get('type')}.{field_name}"
                    field_value[i] = self.METHOD_NAME(parent_type_field_identifier, element, current_parameters)
            if excluded_parameter:
                current_parameters[field_name] = excluded_parameter
    if current_parameters:
        propagated_component[PARAMETERS_STR] = current_parameters
    return propagated_component