It exists and its flags are exported, but not the direct classes itself. This seems inconsistent to me and fixing it would make things like using static typing on it just a little bit easier.

I think RegexFlag is an implementation detail, but it is true that it isn't prefixed with a _ so putting it in __all__ is not obviously wrong.  However, if we do that we should also document it (currently it is mentioned only in a versionchanged line, which isn't technically documenting it).

I find it curious that static typing is affected by __all___, but I don't really know anything about typing.

I suppose it may be an implementation detail, though I wouldn't be amazed that had enum existed when re was written it'd have been used instead of constant integers at the time. Though I do suppose exposing it fully would add two ways to get the flags which I can see how it would be considered bad.

It's still useful for type checking though, and while I did make a PR to add it to typeshed, that still leaves it in an iffy state and I probably would not be the last person to be confused by it initially.

Well, I consider that they really should be named constants and not an enum, which is why I consider it an implementation detail :)

@ethan.furman, since you had originally added RegexFlag in #28082, do have an opinion on this?  Thanks.

I concur with David. This is an imlementation detail. No need to prefix it with a _ if the module uses __all__for public names.

I see no reason no prefix `RegexFlag` with an `_`.

As far as adding it to `__all__` -- I didn't originally because I was trying to mirror the original implementation, but I am not against it.  I would defer that decision to those that work on typing.

I am totally fine with making RegexFlag public (this may be indeed useful for static typing purposes).

Guido, do you have an opinion on adding `RegexFlag` to the `re` module's `__all__` and documenting it?

There is also some discussion on making these types of int-to-Enum conversions use a `module.name` repr instead of `class.name`:

used to be:

    >>> re.I
    <RegexFlag.I: 2>

is now:

    >>> re.I
    re.IGNORECASE

I of course have no idea if that matters to typing one way or the other.

What it prints is irrelevant to static checking.

Currently the typeshed stub for the code already exports RegexFlag, so that the following passes mypy but fails at runtime:
```
from re import *

def foo(flag: RegexFlag):
    return match("[a-z]+", "ABC", flag)

print(foo(IGNORECASE))
print(foo(VERBOSE))
```
I think it's good to add it to `__all__` so this code will not put the type checker to shame, and it would be good to document it.

One thing I discovered when developing this example: there doesn't seem to be a flag to represent 0 (zero), i.e. "no flags".  And foo(0) is a type error (even though it works fine at runtime).