CFModel

def resolve(self, extra_params=None) -> "CFModel":
    """
    Resolve all intrinsic functions on the template.

    Arguments:
        extra_params: Values of parameters passed to the Cloudformation.

    Returns:
        A new CFModel.
    """
    extra_params = {} if extra_params is None else extra_params
    # default parameters
    params = {}
    for key, parameter in self.Parameters.items():
        passed_value = extra_params.pop(key, None)
        ref_value = parameter.get_ref_value(passed_value)
        if ref_value is not None:
            params[key] = ref_value

    extended_parameters = {**self.PSEUDO_PARAMETERS, **params, **extra_params}
    dict_value = self.dict()

    if self.Conditions:
        conditions = dict_value.pop("Conditions")
    else:
        conditions = {}
    resolved_conditions = {
        key: _extended_bool(resolve(value, extended_parameters, self.Mappings, {}))
        for key, value in conditions.items()
    }

    resources = dict_value.pop("Resources")
    resolved_resources = {
        key: resolve(value, extended_parameters, self.Mappings, resolved_conditions)
        for key, value in resources.items()
    }
    return CFModel(**dict_value, Conditions=resolved_conditions, Resources=resolved_resources)

def resources_filtered_by_type(
    self, allowed_types: Collection[Union[str, Type[Resource]]]
) -> Dict[str, Dict[str, Resource]]:
    """
    Filtered resources based on types.

    Arguments:
        allowed_types: Collection of desired types.

    Returns:
        Dictionary where key is the logical id and value is the resource.
    """
    result = {}
    allowed_resource_classes = tuple(x for x in allowed_types if isinstance(x, type))
    for resource_name, resource in self.Resources.items():
        if isinstance(resource, allowed_resource_classes) or resource.Type in allowed_types:
            result[resource_name] = resource
    return result

def get_ref_value(self, provided_value=None) -> Optional[str]:
    """
    Calculates the parameter value to be used in the template.

    - If `NoEcho` property is set, it uses a constant value.
    - If it is a list of numbers or a comma delimited list, returns the string version of each element in a list.
    - Returns None if `provided_value` and `Default` are `None`.

    Arguments:
        provided_value: Value injected in the template

    Returns:
        The computed value.
    """
    value = provided_value if provided_value is not None else self.Default
    if self.NoEcho:
        if provided_value is not None:
            return self.NO_ECHO_WITH_VALUE
        elif self.Default:
            return self.NO_ECHO_WITH_DEFAULT
        else:
            return self.NO_ECHO_NO_DEFAULT

    elif self.Type in ["List<Number>", "CommaDelimitedList"]:
        return value.split(",")

    return value if value is None else str(value)