def opt_stylize(
    self: GTSelf, style: int = 1, color: str = "blue", add_row_striping: bool = True
) -> GTSelf:
    """
    Stylize your table with a colorful look.

    With the `opt_stylize()` method you can quickly style your table with a carefully curated set of
    background colors, line colors, and line styles. There are six styles to choose from and they
    largely vary in the extent of coloring applied to different table locations. Some have table
    borders applied, some apply darker colors to the table stub and summary sections, and, some even
    have vertical lines. In addition to choosing a `style` preset, there are six `color` variations
    that each use a range of five color tints. Each of the color tints have been fine-tuned to
    maximize the contrast between text and its background. There are 36 combinations of `style` and
    `color` to choose from. For examples of each style, see the
    [*Premade Themes*](../get-started/table-theme-premade.qmd) section of the **Get Started**
    guide.

    Parameters
    ----------
    style
        Six numbered styles are available. Simply provide a number from `1` (the default) to `6` to
        choose a distinct look.
    color
        The color scheme of the table. The default value is `"blue"`. The valid values are `"blue"`,
        `"cyan"`, `"pink"`, `"green"`, `"red"`, and `"gray"`.
    add_row_striping
        An option to enable row striping in the table body for the style chosen.

    Returns
    -------
    GT
        The GT object is returned. This is the same object that the method is called on so that we
        can facilitate method chaining.

    Examples
    --------
    Using select columns from the `exibble` dataset, let's create a table with a number of
    components added. Following that, we'll apply a predefined style to the table using the
    `opt_stylize()` method.

    ```{python}
    from great_tables import GT, exibble, md

    gt_tbl = (
          GT(
            exibble[["num", "char", "currency", "row", "group"]],
            rowname_col="row",
            groupname_col="group"
          )
          .tab_header(
            title=md("Data listing from **exibble**"),
            subtitle=md("`exibble` is a **Great Tables** dataset.")
          )
          .fmt_number(columns="num")
          .fmt_currency(columns="currency")
          .tab_source_note(source_note="This is only a subset of the dataset.")
          .opt_stylize()
        )

    gt_tbl
    ```

    The table has been stylized with the default style and color. The default style is `1` and the
    default color is `"blue"`. The resulting table style is a combination of color and border
    settings that are applied to the table.

    We can modify the overall style and choose a different color theme by providing different values
    to the `style=` and `color=` arguments.

    ```{python}
    gt_tbl.opt_stylize(style=2, color="green")
    ```
    """

    # Validate the `style` and `color` arguments
    if style not in [1, 2, 3, 4, 5, 6]:
        raise ValueError("`style` must be an integer value from `1` to `6`.")
    color = _utils._match_arg(x=color, lst=["gray", "blue", "cyan", "pink", "green", "red"])

    # Get the style parameters based on the `style` and `color` arguments
    params = _dict_styles_colors_params[f"{color}-{style}"]

    # Omit keys that are not needed for the `tab_options()` method
    # TODO: the omitted keys are for future use when:
    #  (1) summary rows are implemented
    #  (2) grand summary rows are implemented
    omit_keys = {
        "summary_row_background_color",
        "grand_summary_row_background_color",
    }

    def dict_omit_keys(dict: dict[str, str], omit_keys: set[str]) -> dict[str, str]:
        return {x: v for x, v in dict.items() if x not in omit_keys}

    params = dict_omit_keys(dict=params, omit_keys=omit_keys)

    mapped_params = StyleMapper(**params).map_all()

    # Add the `add_row_striping` parameter to the `mapped_params` dictionary
    if add_row_striping:
        mapped_params["row_striping_include_table_body"] = ["True"]

    if style in [2, 4, 5]:
        # For styles 2, 4, and 5 we need to set the border colors and widths

        # Use a dictionary comprehension to generate the border parameters
        directions = ["top", "bottom", "left", "right"]
        attributes = ["color", "width", "style"]

        border_params: dict[str, str] = {
            f"table_border_{d}_{a}": (
                "#D5D5D5" if a == "color" else "3px" if a == "width" else "solid"
            )
            for d in directions
            for a in attributes
        }

        # Append the border parameters to the `mapped_params` dictionary
        mapped_params.update(border_params)

    # Apply the style parameters to the table using the `tab_options()` method
    res = tab_options(self=self, **mapped_params)

    return res

    Stylize your table with a colorful look.

    With the `opt_stylize()` method you can quickly style your table with a carefully curated set of
    background colors, line colors, and line styles. There are six styles to choose from and they
    largely vary in the extent of coloring applied to different table locations. Some have table
    borders applied, some apply darker colors to the table stub and summary sections, and, some even
    have vertical lines. In addition to choosing a `style` preset, there are six `color` variations
    that each use a range of five color tints. Each of the color tints have been fine-tuned to
    maximize the contrast between text and its background. There are 36 combinations of `style` and
    `color` to choose from. For examples of each style, see the
    [*Premade Themes*](../get-started/table-theme-premade.qmd) section of the **Get Started**
    guide.

    Parameters
    ----------
    style
        Six numbered styles are available. Simply provide a number from `1` (the default) to `6` to
        choose a distinct look.
    color
        The color scheme of the table. The default value is `"blue"`. The valid values are `"blue"`,
        `"cyan"`, `"pink"`, `"green"`, `"red"`, and `"gray"`.
    add_row_striping
        An option to enable row striping in the table body for the style chosen.

    Returns
    -------
    GT
        The GT object is returned. This is the same object that the method is called on so that we
        can facilitate method chaining.

    Examples
    --------
    Using select columns from the `exibble` dataset, let's create a table with a number of
    components added. Following that, we'll apply a predefined style to the table using the
    `opt_stylize()` method.

    ```{python}
    from great_tables import GT, exibble, md

    gt_tbl = (
          GT(
            exibble[["num", "char", "currency", "row", "group"]],
            rowname_col="row",
            groupname_col="group"
          )
          .tab_header(
            title=md("Data listing from **exibble**"),
            subtitle=md("`exibble` is a **Great Tables** dataset.")
          )
          .fmt_number(columns="num")
          .fmt_currency(columns="currency")
          .tab_source_note(source_note="This is only a subset of the dataset.")
          .opt_stylize()
        )

    gt_tbl
    ```

    The table has been stylized with the default style and color. The default style is `1` and the
    default color is `"blue"`. The resulting table style is a combination of color and border
    settings that are applied to the table.

    We can modify the overall style and choose a different color theme by providing different values
    to the `style=` and `color=` arguments.

    ```{python}
    gt_tbl.opt_stylize(style=2, color="green")
    ```
    
great_tables/_options.py