def build_configurable_transformation_enum() -> ConfigurableComponent:
    """
    Build an enum of configurable transformations.
    But conditional on if the corresponding component is available.
    """
    enum_members = []

    # Node parsers
    enum_members.append(
        (
            "CODE_NODE_PARSER",
            ConfigurableTransformation(
                name="Code Splitter",
                transformation_category=TransformationCategories.NODE_PARSER,
                component_type=CodeSplitter,
            ),
        )
    )

    enum_members.append(
        (
            "SENTENCE_AWARE_NODE_PARSER",
            ConfigurableTransformation(
                name="Sentence Splitter",
                transformation_category=TransformationCategories.NODE_PARSER,
                component_type=SentenceSplitter,
            ),
        )
    )

    enum_members.append(
        (
            "TOKEN_AWARE_NODE_PARSER",
            ConfigurableTransformation(
                name="Token Text Splitter",
                transformation_category=TransformationCategories.NODE_PARSER,
                component_type=TokenTextSplitter,
            ),
        )
    )

    enum_members.append(
        (
            "HTML_NODE_PARSER",
            ConfigurableTransformation(
                name="HTML Node Parser",
                transformation_category=TransformationCategories.NODE_PARSER,
                component_type=HTMLNodeParser,
            ),
        )
    )

    enum_members.append(
        (
            "MARKDOWN_NODE_PARSER",
            ConfigurableTransformation(
                name="Markdown Node Parser",
                transformation_category=TransformationCategories.NODE_PARSER,
                component_type=MarkdownNodeParser,
            ),
        )
    )

    enum_members.append(
        (
            "JSON_NODE_PARSER",
            ConfigurableTransformation(
                name="JSON Node Parser",
                transformation_category=TransformationCategories.NODE_PARSER,
                component_type=JSONNodeParser,
            ),
        )
    )

    enum_members.append(
        (
            "SIMPLE_FILE_NODE_PARSER",
            ConfigurableTransformation(
                name="Simple File Node Parser",
                transformation_category=TransformationCategories.NODE_PARSER,
                component_type=SimpleFileNodeParser,
            ),
        )
    )

    enum_members.append(
        (
            "MARKDOWN_ELEMENT_NODE_PARSER",
            ConfigurableTransformation(
                name="Markdown Element Node Parser",
                transformation_category=TransformationCategories.NODE_PARSER,
                component_type=MarkdownElementNodeParser,
            ),
        )
    )

    # Embeddings
    try:
        from llama_index.embeddings.openai import OpenAIEmbedding  # pants: no-infer-dep

        enum_members.append(
            (
                "OPENAI_EMBEDDING",
                ConfigurableTransformation(
                    name="OpenAI Embedding",
                    transformation_category=TransformationCategories.EMBEDDING,
                    component_type=OpenAIEmbedding,
                ),
            )
        )
    except (ImportError, ValidationError):
        pass

    try:
        from llama_index.embeddings.azure_openai import (
            AzureOpenAIEmbedding,
        )  # pants: no-infer-dep

        enum_members.append(
            (
                "AZURE_EMBEDDING",
                ConfigurableTransformation(
                    name="Azure OpenAI Embedding",
                    transformation_category=TransformationCategories.EMBEDDING,
                    component_type=AzureOpenAIEmbedding,
                ),
            )
        )
    except (ImportError, ValidationError):
        pass

    try:
        from llama_index.embeddings.cohere import (
            CohereEmbedding,
        )  # pants: no-infer-dep

        enum_members.append(
            (
                "COHERE_EMBEDDING",
                ConfigurableTransformation(
                    name="Cohere Embedding",
                    transformation_category=TransformationCategories.EMBEDDING,
                    component_type=CohereEmbedding,
                ),
            )
        )
    except (ImportError, ValidationError):
        pass

    try:
        from llama_index.embeddings.bedrock import (
            BedrockEmbedding,
        )  # pants: no-infer-dep

        enum_members.append(
            (
                "BEDROCK_EMBEDDING",
                ConfigurableTransformation(
                    name="Bedrock Embedding",
                    transformation_category=TransformationCategories.EMBEDDING,
                    component_type=BedrockEmbedding,
                ),
            )
        )
    except (ImportError, ValidationError):
        pass

    try:
        from llama_index.embeddings.huggingface_api import (
            HuggingFaceInferenceAPIEmbedding,
        )  # pants: no-infer-dep

        enum_members.append(
            (
                "HUGGINGFACE_API_EMBEDDING",
                ConfigurableTransformation(
                    name="HuggingFace API Embedding",
                    transformation_category=TransformationCategories.EMBEDDING,
                    component_type=HuggingFaceInferenceAPIEmbedding,
                ),
            )
        )
    except (ImportError, ValidationError):
        pass

    try:
        from llama_index.embeddings.gemini import (
            GeminiEmbedding,
        )  # pants: no-infer-dep

        enum_members.append(
            (
                "GEMINI_EMBEDDING",
                ConfigurableTransformation(
                    name="Gemini Embedding",
                    transformation_category=TransformationCategories.EMBEDDING,
                    component_type=GeminiEmbedding,
                ),
            )
        )
    except (ImportError, ValidationError):
        pass

    try:
        from llama_index.embeddings.mistralai import (
            MistralAIEmbedding,
        )  # pants: no-infer-dep

        enum_members.append(
            (
                "MISTRALAI_EMBEDDING",
                ConfigurableTransformation(
                    name="MistralAI Embedding",
                    transformation_category=TransformationCategories.EMBEDDING,
                    component_type=MistralAIEmbedding,
                ),
            )
        )
    except (ImportError, ValidationError):
        pass

    return ConfigurableComponent("ConfigurableTransformations", enum_members)  # type: ignore

    Build an enum of configurable transformations.
    But conditional on if the corresponding component is available.
    
llama-index-core/llama_index/core/ingestion/transformations.py