diff --git a/pykusto/_src/client.py b/pykusto/_src/client.py
index 5ca6939..76b9337 100644
--- a/pykusto/_src/client.py
+++ b/pykusto/_src/client.py
@@ -128,12 +128,12 @@ class PyKustoClient(_ItemFetcher):
     def to_query_format(self) -> KQL:
         return KQL(f'cluster("{self.__cluster_name}")')
 
-    def _new_item(self, name: str) -> '_Database':
+    def _new_item(self, name: str) -> 'Database':
         # "fetch_by_default" set to false because often a database generated this way is not represented by an actual
         # Kusto database
-        return _Database(self, name, fetch_by_default=False)
+        return Database(self, name, fetch_by_default=False)
 
-    def get_database(self, name: str) -> '_Database':
+    def get_database(self, name: str) -> 'Database':
         return self[name]
 
     def execute(self, database: str, query: KQL, properties: ClientRequestProperties = None, retry_config: RetryConfig = None) -> KustoResponse:
@@ -152,7 +152,7 @@ class PyKustoClient(_ItemFetcher):
     def get_databases_names(self) -> Generator[str, None, None]:
         yield from self._get_item_names()
 
-    def get_databases(self) -> Generator['_Database', None, None]:
+    def get_databases(self) -> Generator['Database', None, None]:
         yield from self._get_items()
 
     def get_cluster_name(self) -> str:
@@ -179,7 +179,7 @@ class PyKustoClient(_ItemFetcher):
         """
         return PyKustoClient._get_client_for_cluster(cluster)
 
-    def _internal_get_items(self) -> Dict[str, '_Database']:
+    def _internal_get_items(self) -> Dict[str, 'Database']:
         # Retrieves database names, table names, column names and types for all databases. A database name is required
         # by the "execute" method, but is ignored for this query
         res: KustoResponse = self.execute(
@@ -193,7 +193,7 @@ class PyKustoClient(_ItemFetcher):
         return {
             # Database instances are provided with all table and column data, preventing them from generating more
             # queries. However the "fetch_by_default" behavior is passed on to them for future actions.
-            database_name: _Database(
+            database_name: Database(
                 self, database_name,
                 {table_name: tuple(columns) for table_name, columns in table_to_columns.items()},
                 fetch_by_default=self._fetch_by_default
@@ -202,7 +202,7 @@ class PyKustoClient(_ItemFetcher):
         }
 
 
-class _Database(_ItemFetcher):
+class Database(_ItemFetcher):
     """
     Handle to a Kusto database.
     Uses :class:`ItemFetcher` to fetch and cache the full database schema, including all tables, columns and their
@@ -228,7 +228,7 @@ class _Database(_ItemFetcher):
             # Providing the items to ItemFetcher prevents further queries until the "refresh" method is explicitly
             # called
             None if tables is None else {
-                table_name: _Table(self, table_name, columns, fetch_by_default=fetch_by_default)
+                table_name: Table(self, table_name, columns, fetch_by_default=fetch_by_default)
                 for table_name, columns in tables.items()
             },
             fetch_by_default
@@ -246,10 +246,10 @@ class _Database(_ItemFetcher):
     def get_name(self) -> str:
         return self.__name
 
-    def _new_item(self, name: str) -> '_Table':
+    def _new_item(self, name: str) -> 'Table':
         # "fetch_by_default" set to false because often a table generated this way is not represented by an actual
         # Kusto table
-        return _Table(self, name, fetch_by_default=False)
+        return Table(self, name, fetch_by_default=False)
 
     def execute(self, query: KQL, properties: ClientRequestProperties = None, retry_config: RetryConfig = None) -> KustoResponse:
         return self.__client.execute(self.__name, query, properties, retry_config)
@@ -257,13 +257,13 @@ class _Database(_ItemFetcher):
     def get_table_names(self) -> Generator[str, None, None]:
         yield from self._get_item_names()
 
-    def get_table(self, *tables: str) -> '_Table':
+    def get_table(self, *tables: str) -> 'Table':
         assert len(tables) > 0
-        if not _Table.static_is_union(*tables):
+        if not Table.static_is_union(*tables):
             return self[tables[0]]
         columns: Optional[Tuple[BaseColumn, ...]] = None
         if self._items_fetched():
-            resolved_tables: Set[_Table] = set()
+            resolved_tables: Set[Table] = set()
             for table_pattern in tables:
                 if '*' in table_pattern:
                     resolved_tables.update(table for table in self._get_items() if fnmatch(table.get_name(), table_pattern))
@@ -272,10 +272,10 @@ class _Database(_ItemFetcher):
             if len(resolved_tables) == 1:
                 return next(iter(resolved_tables))
             columns = self.__try_to_resolve_union_columns(*resolved_tables)
-        return _Table(self, tables, columns, fetch_by_default=self._fetch_by_default)
+        return Table(self, tables, columns, fetch_by_default=self._fetch_by_default)
 
     @staticmethod
-    def __try_to_resolve_union_columns(*resolved_tables: '_Table') -> Optional[Tuple[BaseColumn, ...]]:
+    def __try_to_resolve_union_columns(*resolved_tables: 'Table') -> Optional[Tuple[BaseColumn, ...]]:
         column_by_name: Dict[str, BaseColumn] = {}
         for table in resolved_tables:
             for column in table.get_columns():
@@ -284,7 +284,7 @@ class _Database(_ItemFetcher):
                     return None  # Fallback to Kusto query for column name conflict resolution
         return tuple(column_by_name.values())
 
-    def _internal_get_items(self) -> Dict[str, '_Table']:
+    def _internal_get_items(self) -> Dict[str, 'Table']:
         # Retrieves table names, column names and types for this database only (the database name is added in the
         # "execute" method)
         res: KustoResponse = self.execute(
@@ -297,21 +297,21 @@ class _Database(_ItemFetcher):
         # "fetch_by_default" behavior is
         # passed on to them for future actions.
         return {
-            table_name: _Table(self, table_name, tuple(columns), fetch_by_default=self._fetch_by_default)
+            table_name: Table(self, table_name, tuple(columns), fetch_by_default=self._fetch_by_default)
             for table_name, columns in table_to_columns.items()
         }
 
 
-class _Table(_ItemFetcher):
+class Table(_ItemFetcher):
     """
     Handle to a Kusto table.
     Uses :class:`ItemFetcher` to fetch and cache the table schema of columns and their types.
     """
-    __database: _Database
+    __database: Database
     __tables: Tuple[str, ...]
 
     def __init__(
-            self, database: _Database, tables: Union[str, List[str], Tuple[str, ...]],
+            self, database: Database, tables: Union[str, List[str], Tuple[str, ...]],
             columns: Tuple[BaseColumn, ...] = None, fetch_by_default: bool = True
     ) -> None:
         """
diff --git a/pykusto/_src/expressions.py b/pykusto/_src/expressions.py
index 16d1ca7..4a4c05d 100644
--- a/pykusto/_src/expressions.py
+++ b/pykusto/_src/expressions.py
@@ -7,16 +7,16 @@ from .kql_converters import KQL
 from .type_utils import _plain_expression, _aggregation_expression, PythonTypes, _kql_converter, _KustoType, \
     _typed_column, _TypeRegistrar, _get_base_types, _NUMBER_TYPES
 
-_ExpressionType = Union[PythonTypes, 'BaseExpression']
-_StringType = Union[str, '_StringExpression']
-_BooleanType = Union[bool, '_BooleanExpression']
-_NumberType = Union[int, float, '_NumberExpression']
-_ArrayType = Union[List, Tuple, '_ArrayExpression']
-_MappingType = Union[Mapping, '_MappingExpression']
-_DatetimeType = Union[datetime, '_DatetimeExpression']
-_TimespanType = Union[timedelta, '_TimespanExpression']
-_DynamicType = Union[_ArrayType, _MappingType]
-_OrderedType = Union[_DatetimeType, _TimespanType, _NumberType, _StringType]
+ExpressionType = Union[PythonTypes, 'BaseExpression']
+StringType = Union[str, '_StringExpression']
+BooleanType = Union[bool, '_BooleanExpression']
+NumberType = Union[int, float, '_NumberExpression']
+ArrayType = Union[List, Tuple, '_ArrayExpression']
+MappingType = Union[Mapping, '_MappingExpression']
+DatetimeType = Union[datetime, '_DatetimeExpression']
+TimespanType = Union[timedelta, '_TimespanExpression']
+DynamicType = Union[ArrayType, MappingType]
+OrderedType = Union[DatetimeType, TimespanType, NumberType, StringType]
 
 
 # All classes in the same file to prevent circular dependencies
@@ -81,7 +81,7 @@ class BaseExpression:
 
     @staticmethod
     def base_binary_op(
-            left: _ExpressionType, operator: str, right: _ExpressionType, result_type: Optional[_KustoType]
+            left: ExpressionType, operator: str, right: ExpressionType, result_type: Optional[_KustoType]
     ) -> 'BaseExpression':
         registrar = _plain_expression
         fallback = AnyExpression
@@ -91,13 +91,13 @@ class BaseExpression:
         return_type = fallback if result_type is None else registrar.registry[result_type]
         return return_type(KQL(f'{_to_kql(left, True)}{operator}{_to_kql(right, True)}'))
 
-    def __eq__(self, other: _ExpressionType) -> '_BooleanExpression':
+    def __eq__(self, other: ExpressionType) -> '_BooleanExpression':
         return _BooleanExpression.binary_op(self, ' == ', other)
 
-    def __ne__(self, other: _ExpressionType) -> '_BooleanExpression':
+    def __ne__(self, other: ExpressionType) -> '_BooleanExpression':
         return _BooleanExpression.binary_op(self, ' != ', other)
 
-    def is_in(self, other: _DynamicType, case_sensitive: bool = False) -> '_BooleanExpression':
+    def is_in(self, other: DynamicType, case_sensitive: bool = False) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/scalar-data-types/dynamic#operators-and-functions-over-dynamic-types
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/inoperator
@@ -116,7 +116,7 @@ class BaseExpression:
         assert case_sensitive, "Member test for non-literal array cannot be case insensitive"
         return _BooleanExpression(KQL(f'set_has_element({_to_kql(other)}, {self.kql})'))
 
-    def not_in(self, other: _DynamicType, case_sensitive: bool = False) -> '_BooleanExpression':
+    def not_in(self, other: DynamicType, case_sensitive: bool = False) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/scalar-data-types/dynamic#operators-and-functions-over-dynamic-types
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/inoperator
@@ -197,29 +197,29 @@ class BaseExpression:
 @_plain_expression(_KustoType.BOOL)
 class _BooleanExpression(BaseExpression):
     @staticmethod
-    def binary_op(left: _ExpressionType, operator: str, right: _ExpressionType) -> '_BooleanExpression':
+    def binary_op(left: ExpressionType, operator: str, right: ExpressionType) -> '_BooleanExpression':
         # noinspection PyTypeChecker
         return BaseExpression.base_binary_op(left, operator, right, _KustoType.BOOL)
 
-    def __and__(self, other: _BooleanType) -> '_BooleanExpression':
+    def __and__(self, other: BooleanType) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/logicaloperators
         """
         return _BooleanExpression.binary_op(self, ' and ', other)
 
-    def __rand__(self, other: _BooleanType) -> '_BooleanExpression':
+    def __rand__(self, other: BooleanType) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/logicaloperators
         """
         return _BooleanExpression.binary_op(other, ' and ', self)
 
-    def __or__(self, other: _BooleanType) -> '_BooleanExpression':
+    def __or__(self, other: BooleanType) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/logicaloperators
         """
         return _BooleanExpression.binary_op(self, ' or ', other)
 
-    def __ror__(self, other: _BooleanType) -> '_BooleanExpression':
+    def __ror__(self, other: BooleanType) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/logicaloperators
         """
@@ -236,50 +236,50 @@ class _BooleanExpression(BaseExpression):
 @_plain_expression(*_NUMBER_TYPES)
 class _NumberExpression(BaseExpression):
     @staticmethod
-    def binary_op(left: _NumberType, operator: str, right: _NumberType) -> '_NumberExpression':
+    def binary_op(left: NumberType, operator: str, right: NumberType) -> '_NumberExpression':
         # noinspection PyTypeChecker
         return BaseExpression.base_binary_op(left, operator, right, _KustoType.INT)
 
-    def __lt__(self, other: _NumberType) -> _BooleanExpression:
+    def __lt__(self, other: NumberType) -> _BooleanExpression:
         return _BooleanExpression.binary_op(self, ' < ', other)
 
-    def __le__(self, other: _NumberType) -> _BooleanExpression:
+    def __le__(self, other: NumberType) -> _BooleanExpression:
         return _BooleanExpression.binary_op(self, ' <= ', other)
 
-    def __gt__(self, other: _NumberType) -> _BooleanExpression:
+    def __gt__(self, other: NumberType) -> _BooleanExpression:
         return _BooleanExpression.binary_op(self, ' > ', other)
 
-    def __ge__(self, other: _NumberType) -> _BooleanExpression:
+    def __ge__(self, other: NumberType) -> _BooleanExpression:
         return _BooleanExpression.binary_op(self, ' >= ', other)
 
-    def __add__(self, other: _NumberType) -> '_NumberExpression':
+    def __add__(self, other: NumberType) -> '_NumberExpression':
         return _NumberExpression.binary_op(self, ' + ', other)
 
-    def __radd__(self, other: _NumberType) -> '_NumberExpression':
+    def __radd__(self, other: NumberType) -> '_NumberExpression':
         return _NumberExpression.binary_op(other, ' + ', self)
 
-    def __sub__(self, other: _NumberType) -> '_NumberExpression':
+    def __sub__(self, other: NumberType) -> '_NumberExpression':
         return _NumberExpression.binary_op(self, ' - ', other)
 
-    def __rsub__(self, other: _NumberType) -> '_NumberExpression':
+    def __rsub__(self, other: NumberType) -> '_NumberExpression':
         return _NumberExpression.binary_op(other, ' - ', self)
 
-    def __mul__(self, other: _NumberType) -> '_NumberExpression':
+    def __mul__(self, other: NumberType) -> '_NumberExpression':
         return _NumberExpression.binary_op(self, ' * ', other)
 
-    def __rmul__(self, other: _NumberType) -> '_NumberExpression':
+    def __rmul__(self, other: NumberType) -> '_NumberExpression':
         return _NumberExpression.binary_op(other, ' * ', self)
 
-    def __truediv__(self, other: _NumberType) -> '_NumberExpression':
+    def __truediv__(self, other: NumberType) -> '_NumberExpression':
         return _NumberExpression.binary_op(self, ' / ', other)
 
-    def __rtruediv__(self, other: _NumberType) -> '_NumberExpression':
+    def __rtruediv__(self, other: NumberType) -> '_NumberExpression':
         return _NumberExpression.binary_op(other, ' / ', self)
 
-    def __mod__(self, other: _NumberType) -> '_NumberExpression':
+    def __mod__(self, other: NumberType) -> '_NumberExpression':
         return _NumberExpression.binary_op(self, ' % ', other)
 
-    def __rmod__(self, other: _NumberType) -> '_NumberExpression':
+    def __rmod__(self, other: NumberType) -> '_NumberExpression':
         return _NumberExpression.binary_op(other, ' % ', self)
 
     def __neg__(self) -> '_NumberExpression':
@@ -291,7 +291,7 @@ class _NumberExpression(BaseExpression):
         """
         return _NumberExpression(KQL(f'abs({self.kql})'))
 
-    def between(self, lower: _NumberType, upper: _NumberType) -> _BooleanExpression:
+    def between(self, lower: NumberType, upper: NumberType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/betweenoperator
         """
@@ -309,19 +309,19 @@ class _NumberExpression(BaseExpression):
         """
         return _NumberExpression(KQL(f'cos({self.kql})'))
 
-    def floor(self, round_to: _NumberType) -> '_NumberExpression':
+    def floor(self, round_to: NumberType) -> '_NumberExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/floorfunction
         """
         return _NumberExpression(KQL(f'floor({self.kql}, {_to_kql(round_to)})'))
 
-    def bin(self, round_to: _NumberType) -> 'BaseExpression':
+    def bin(self, round_to: NumberType) -> 'BaseExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/binfunction
         """
         return _NumberExpression(KQL(f'bin({self.kql}, {_to_kql(round_to)})'))
 
-    def bin_at(self, round_to: _NumberType, fixed_point: _NumberType) -> 'BaseExpression':
+    def bin_at(self, round_to: NumberType, fixed_point: NumberType) -> 'BaseExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/binatfunction
         """
@@ -399,7 +399,7 @@ class _NumberExpression(BaseExpression):
         """
         return _NumberExpression(KQL(f'loggamma({self.kql})'))
 
-    def round(self, precision: _NumberType = None) -> '_NumberExpression':
+    def round(self, precision: NumberType = None) -> '_NumberExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/roundfunction
         """
@@ -415,7 +415,7 @@ class _StringExpression(BaseExpression):
         """
         return _NumberExpression(KQL(f'string_size({self.kql})'))
 
-    def split(self, delimiter: _StringType, requested_index: _NumberType = None) -> '_ArrayExpression':
+    def split(self, delimiter: StringType, requested_index: NumberType = None) -> '_ArrayExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/splitfunction
         """
@@ -423,7 +423,7 @@ class _StringExpression(BaseExpression):
             return _ArrayExpression(KQL(f'split({self.kql}, {_to_kql(delimiter)})'))
         return _ArrayExpression(KQL(f'split({self.kql}, {_to_kql(delimiter)}, {_to_kql(requested_index)})'))
 
-    def equals(self, other: _StringType, case_sensitive: bool = False) -> _BooleanExpression:
+    def equals(self, other: StringType, case_sensitive: bool = False) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datatypes-string-operators
 
@@ -433,7 +433,7 @@ class _StringExpression(BaseExpression):
         """
         return _BooleanExpression.binary_op(self, ' == ' if case_sensitive else ' =~ ', other)
 
-    def not_equals(self, other: _StringType, case_sensitive: bool = False) -> _BooleanExpression:
+    def not_equals(self, other: StringType, case_sensitive: bool = False) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datatypes-string-operators
 
@@ -443,13 +443,13 @@ class _StringExpression(BaseExpression):
         """
         return _BooleanExpression.binary_op(self, ' != ' if case_sensitive else ' !~ ', other)
 
-    def matches(self, regex: _StringType) -> '_BooleanExpression':
+    def matches(self, regex: StringType) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datatypes-string-operators
         """
         return _BooleanExpression.binary_op(self, ' matches regex ', regex)
 
-    def contains(self, other: _StringType, case_sensitive: bool = False) -> _BooleanExpression:
+    def contains(self, other: StringType, case_sensitive: bool = False) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datatypes-string-operators
 
@@ -460,7 +460,7 @@ class _StringExpression(BaseExpression):
         """
         return _BooleanExpression.binary_op(self, ' contains_cs ' if case_sensitive else ' contains ', other)
 
-    def not_contains(self, other: _StringType, case_sensitive: bool = False) -> _BooleanExpression:
+    def not_contains(self, other: StringType, case_sensitive: bool = False) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datatypes-string-operators
 
@@ -471,13 +471,13 @@ class _StringExpression(BaseExpression):
         """
         return _BooleanExpression.binary_op(self, ' !contains_cs ' if case_sensitive else ' !contains ', other)
 
-    def startswith(self, other: _StringType, case_sensitive: bool = False) -> _BooleanExpression:
+    def startswith(self, other: StringType, case_sensitive: bool = False) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datatypes-string-operators
         """
         return _BooleanExpression.binary_op(self, ' startswith_cs ' if case_sensitive else ' startswith ', other)
 
-    def endswith(self, other: _StringType, case_sensitive: bool = False) -> _BooleanExpression:
+    def endswith(self, other: StringType, case_sensitive: bool = False) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datatypes-string-operators
         """
@@ -507,7 +507,7 @@ class _StringExpression(BaseExpression):
         """
         return _BooleanExpression(KQL(f'isutf8({self.kql})'))
 
-    def has(self, exp: _StringType, case_sensitive: bool = False) -> '_BooleanExpression':
+    def has(self, exp: StringType, case_sensitive: bool = False) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datatypes-string-operators
         """
@@ -515,7 +515,7 @@ class _StringExpression(BaseExpression):
             f'{self.as_subexpression()} {"has_cs" if case_sensitive else "has"} {_to_kql(exp, True)}'
         ))
 
-    def has_not(self, exp: _StringType, case_sensitive: bool = False) -> '_BooleanExpression':
+    def has_not(self, exp: StringType, case_sensitive: bool = False) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datatypes-string-operators
         """
@@ -527,27 +527,27 @@ class _StringExpression(BaseExpression):
 @_plain_expression(_KustoType.DATETIME)
 class _DatetimeExpression(BaseExpression):
     @staticmethod
-    def binary_op(left: _ExpressionType, operator: str, right: _ExpressionType) -> '_DatetimeExpression':
+    def binary_op(left: ExpressionType, operator: str, right: ExpressionType) -> '_DatetimeExpression':
         # noinspection PyTypeChecker
         return BaseExpression.base_binary_op(left, operator, right, _KustoType.DATETIME)
 
-    def __lt__(self, other: _DatetimeType) -> _BooleanExpression:
+    def __lt__(self, other: DatetimeType) -> _BooleanExpression:
         return _BooleanExpression.binary_op(self, ' < ', other)
 
-    def __le__(self, other: _DatetimeType) -> _BooleanExpression:
+    def __le__(self, other: DatetimeType) -> _BooleanExpression:
         return _BooleanExpression.binary_op(self, ' <= ', other)
 
-    def __gt__(self, other: _DatetimeType) -> _BooleanExpression:
+    def __gt__(self, other: DatetimeType) -> _BooleanExpression:
         return _BooleanExpression.binary_op(self, ' > ', other)
 
-    def __ge__(self, other: _DatetimeType) -> _BooleanExpression:
+    def __ge__(self, other: DatetimeType) -> _BooleanExpression:
         return _BooleanExpression.binary_op(self, ' >= ', other)
 
-    def __add__(self, other: _TimespanType) -> '_DatetimeExpression':
+    def __add__(self, other: TimespanType) -> '_DatetimeExpression':
         # https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datetime-timespan-arithmetic
         return _DatetimeExpression.binary_op(self, ' + ', other)
 
-    def __sub__(self, other: Union[_DatetimeType, _TimespanType]) -> Union['_DatetimeExpression', '_TimespanExpression']:
+    def __sub__(self, other: Union[DatetimeType, TimespanType]) -> Union['_DatetimeExpression', '_TimespanExpression']:
         # https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datetime-timespan-arithmetic
 
         # noinspection PyTypeChecker
@@ -560,29 +560,29 @@ class _DatetimeExpression(BaseExpression):
             return_type = _TimespanExpression if next(iter(possible_types)) == _KustoType.DATETIME else _DatetimeExpression
         return return_type(_DatetimeExpression.binary_op(self, ' - ', other))
 
-    def __rsub__(self, other: _DatetimeType) -> '_TimespanExpression':
+    def __rsub__(self, other: DatetimeType) -> '_TimespanExpression':
         # https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datetime-timespan-arithmetic
         return _TimespanExpression.binary_op(other, ' - ', self)
 
-    def between(self, lower: _DatetimeType, upper: _DatetimeType) -> _BooleanExpression:
+    def between(self, lower: DatetimeType, upper: DatetimeType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/betweenoperator
         """
         return _BooleanExpression(KQL(f'{self.kql} between ({_to_kql(lower, True)} .. {_to_kql(upper, True)})'))
 
-    def floor(self, round_to: _TimespanType) -> '_DatetimeExpression':
+    def floor(self, round_to: TimespanType) -> '_DatetimeExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/floorfunction
         """
         return _DatetimeExpression(KQL(f'floor({self.kql}, {_to_kql(round_to)})'))
 
-    def bin(self, round_to: _TimespanType) -> 'BaseExpression':
+    def bin(self, round_to: TimespanType) -> 'BaseExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/binfunction
         """
         return _DatetimeExpression(KQL(f'bin({self.kql}, {_to_kql(round_to)})'))
 
-    def bin_at(self, round_to: _TimespanType, fixed_point: _DatetimeType) -> 'BaseExpression':
+    def bin_at(self, round_to: TimespanType, fixed_point: DatetimeType) -> 'BaseExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/binatfunction
         """
@@ -594,7 +594,7 @@ class _DatetimeExpression(BaseExpression):
         """
         return _DatetimeExpression(KQL(f'bin_auto({self.kql})'))
 
-    def end_of_day(self, offset: _NumberType = None) -> '_DatetimeExpression':
+    def end_of_day(self, offset: NumberType = None) -> '_DatetimeExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/endofdayfunction
         """
@@ -604,7 +604,7 @@ class _DatetimeExpression(BaseExpression):
             res = f'endofday({self.kql}, {_to_kql(offset)})'
         return _DatetimeExpression(KQL(res))
 
-    def end_of_month(self, offset: _NumberType = None) -> '_DatetimeExpression':
+    def end_of_month(self, offset: NumberType = None) -> '_DatetimeExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/endofmonthfunction
         """
@@ -614,7 +614,7 @@ class _DatetimeExpression(BaseExpression):
             res = f'endofmonth({self.kql}, {_to_kql(offset)})'
         return _DatetimeExpression(KQL(res))
 
-    def end_of_week(self, offset: _NumberType = None) -> '_DatetimeExpression':
+    def end_of_week(self, offset: NumberType = None) -> '_DatetimeExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/endofweekfunction
         """
@@ -624,7 +624,7 @@ class _DatetimeExpression(BaseExpression):
             res = f'endofweek({self.kql}, {_to_kql(offset)})'
         return _DatetimeExpression(KQL(res))
 
-    def end_of_year(self, offset: _NumberType = None) -> '_DatetimeExpression':
+    def end_of_year(self, offset: NumberType = None) -> '_DatetimeExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/endofyearfunction
         """
@@ -634,7 +634,7 @@ class _DatetimeExpression(BaseExpression):
             res = f'endofyear({self.kql}, {_to_kql(offset)})'
         return _DatetimeExpression(KQL(res))
 
-    def format_datetime(self, format_string: _StringType) -> _StringExpression:
+    def format_datetime(self, format_string: StringType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/format-datetimefunction
         """
@@ -658,25 +658,25 @@ class _DatetimeExpression(BaseExpression):
         """
         return _NumberExpression(KQL(f'hourofday({self.kql})'))
 
-    def start_of_day(self, offset: _NumberType = None) -> '_DatetimeExpression':
+    def start_of_day(self, offset: NumberType = None) -> '_DatetimeExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/startofdayfunction
         """
         return _DatetimeExpression(KQL(f'startofday({self.kql})' if offset is None else f'startofday({self.kql}, {_to_kql(offset)})'))
 
-    def start_of_month(self, offset: _NumberType = None) -> '_DatetimeExpression':
+    def start_of_month(self, offset: NumberType = None) -> '_DatetimeExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/startofmonthfunction
         """
         return _DatetimeExpression(KQL(f'startofmonth({self.kql})' if offset is None else f'startofmonth({self.kql}, {_to_kql(offset)})'))
 
-    def start_of_week(self, offset: _NumberType = None) -> '_DatetimeExpression':
+    def start_of_week(self, offset: NumberType = None) -> '_DatetimeExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/startofweekfunction
         """
         return _DatetimeExpression(KQL(f'startofweek({self.kql})' if offset is None else f'startofweek({self.kql}, {_to_kql(offset)})'))
 
-    def start_of_year(self, offset: _NumberType = None) -> '_DatetimeExpression':
+    def start_of_year(self, offset: NumberType = None) -> '_DatetimeExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/startofyearfunction
         """
@@ -686,23 +686,23 @@ class _DatetimeExpression(BaseExpression):
 @_plain_expression(_KustoType.TIMESPAN)
 class _TimespanExpression(BaseExpression):
     @staticmethod
-    def binary_op(left: _ExpressionType, operator: str, right: _ExpressionType) -> '_TimespanExpression':
+    def binary_op(left: ExpressionType, operator: str, right: ExpressionType) -> '_TimespanExpression':
         # noinspection PyTypeChecker
         return BaseExpression.base_binary_op(left, operator, right, _KustoType.TIMESPAN)
 
-    def __add__(self, other: _TimespanType) -> '_TimespanExpression':
+    def __add__(self, other: TimespanType) -> '_TimespanExpression':
         # https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datetime-timespan-arithmetic
         return _TimespanExpression.binary_op(self, ' + ', other)
 
-    def __radd__(self, other: _TimespanType) -> '_TimespanExpression':
+    def __radd__(self, other: TimespanType) -> '_TimespanExpression':
         # https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datetime-timespan-arithmetic
         return _TimespanExpression.binary_op(other, ' + ', self)
 
-    def __sub__(self, other: _TimespanType) -> '_TimespanExpression':
+    def __sub__(self, other: TimespanType) -> '_TimespanExpression':
         # https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datetime-timespan-arithmetic
         return _TimespanExpression.binary_op(self, ' - ', other)
 
-    def __rsub__(self, other: _TimespanType) -> '_TimespanExpression':
+    def __rsub__(self, other: TimespanType) -> '_TimespanExpression':
         # https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/datetime-timespan-arithmetic
         return _TimespanExpression.binary_op(other, ' - ', self)
 
@@ -712,13 +712,13 @@ class _TimespanExpression(BaseExpression):
         """
         return _DatetimeExpression(KQL(f'ago({_to_kql(self)})'))
 
-    def bin(self, round_to: _TimespanType) -> 'BaseExpression':
+    def bin(self, round_to: TimespanType) -> 'BaseExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/binfunction
         """
         return _TimespanExpression(KQL(f'bin({self.kql}, {_to_kql(round_to)})'))
 
-    def bin_at(self, round_to: _TimespanType, fixed_point: _TimespanType) -> 'BaseExpression':
+    def bin_at(self, round_to: TimespanType, fixed_point: TimespanType) -> 'BaseExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/binatfunction
         """
@@ -730,13 +730,13 @@ class _TimespanExpression(BaseExpression):
         """
         return _TimespanExpression(KQL(f'bin_auto({self.kql})'))
 
-    def format_timespan(self, format_string: _StringType) -> _StringExpression:
+    def format_timespan(self, format_string: StringType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/format-timespanfunction
         """
         return _StringExpression(KQL(f'format_timespan({self.kql}, {_to_kql(format_string)})'))
 
-    def between(self, lower: _TimespanType, upper: _TimespanType) -> _BooleanExpression:
+    def between(self, lower: TimespanType, upper: TimespanType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/betweenoperator
         """
@@ -750,10 +750,10 @@ class _BaseDynamicExpression(BaseExpression):
         assert cls is not _BaseDynamicExpression, "BaseDynamicExpression is abstract"
         return object.__new__(cls)
 
-    def __getitem__(self, index: Union[_StringType, _NumberType]) -> 'AnyExpression':
+    def __getitem__(self, index: Union[StringType, NumberType]) -> 'AnyExpression':
         return AnyExpression(KQL(f'{self.kql}[{_to_kql(index)}]'))
 
-    def contains(self, other: _ExpressionType) -> '_BooleanExpression':
+    def contains(self, other: ExpressionType) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/scalar-data-types/dynamic#operators-and-functions-over-dynamic-types
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/inoperator
@@ -768,7 +768,7 @@ class _BaseDynamicExpression(BaseExpression):
 
 @_plain_expression(_KustoType.ARRAY)
 class _ArrayExpression(_BaseDynamicExpression):
-    def __getitem__(self, index: _NumberType) -> 'AnyExpression':
+    def __getitem__(self, index: NumberType) -> 'AnyExpression':
         return super().__getitem__(index)
 
     # We would like to allow using len(), but Python requires it to return an int, so we can't
@@ -778,7 +778,7 @@ class _ArrayExpression(_BaseDynamicExpression):
         """
         return _NumberExpression(KQL(f'array_length({self.kql})'))
 
-    def array_contains(self, other: _ExpressionType) -> '_BooleanExpression':
+    def array_contains(self, other: ExpressionType) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/scalar-data-types/dynamic#operators-and-functions-over-dynamic-types
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/inoperator
@@ -792,7 +792,7 @@ class _ArrayExpression(_BaseDynamicExpression):
 
 @_plain_expression(_KustoType.MAPPING)
 class _MappingExpression(_BaseDynamicExpression):
-    def __getitem__(self, index: _StringType) -> 'AnyExpression':
+    def __getitem__(self, index: StringType) -> 'AnyExpression':
         return super().__getitem__(index)
 
     def __getattr__(self, name: str) -> 'AnyExpression':
@@ -804,7 +804,7 @@ class _MappingExpression(_BaseDynamicExpression):
         """
         return _ArrayExpression(KQL(f'bag_keys({self.kql})'))
 
-    def bag_contains(self, other: _ExpressionType) -> '_BooleanExpression':
+    def bag_contains(self, other: ExpressionType) -> '_BooleanExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/scalar-data-types/dynamic#operators-and-functions-over-dynamic-types
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/inoperator
@@ -814,7 +814,7 @@ class _MappingExpression(_BaseDynamicExpression):
 
 
 class _DynamicExpression(_ArrayExpression, _MappingExpression):
-    def __getitem__(self, index: Union[_StringType, _NumberType]) -> 'AnyExpression':
+    def __getitem__(self, index: Union[StringType, NumberType]) -> 'AnyExpression':
         return super().__getitem__(index)
 
 
@@ -889,7 +889,7 @@ class _AssignmentBase:
     _lvalue: Optional[KQL]
     _rvalue: KQL
 
-    def __init__(self, lvalue: Optional[KQL], rvalue: _ExpressionType) -> None:
+    def __init__(self, lvalue: Optional[KQL], rvalue: ExpressionType) -> None:
         self._lvalue = lvalue
         self._rvalue = _to_kql(rvalue)
 
@@ -901,7 +901,7 @@ class _AssignmentBase:
 
 
 class _AssignmentToSingleColumn(_AssignmentBase):
-    def __init__(self, column: '_AnyTypeColumn', expression: _ExpressionType) -> None:
+    def __init__(self, column: '_AnyTypeColumn', expression: ExpressionType) -> None:
         super().__init__(column.kql, expression)
 
 
@@ -911,7 +911,7 @@ class _AssignmentFromColumnToColumn(_AssignmentToSingleColumn):
 
 
 class _AssignmentToMultipleColumns(_AssignmentBase):
-    def __init__(self, columns: Union[List['_AnyTypeColumn'], Tuple['_AnyTypeColumn']], expression: _ArrayType) -> None:
+    def __init__(self, columns: Union[List['_AnyTypeColumn'], Tuple['_AnyTypeColumn']], expression: ArrayType) -> None:
         super().__init__(KQL(f'({", ".join(c.kql for c in columns)})'), expression)
 
 
@@ -992,7 +992,7 @@ class _TimespanColumn(BaseColumn, _TimespanExpression):
 
 class _SubtractableColumn(_NumberColumn, _DatetimeColumn, _TimespanColumn):
     @staticmethod
-    def __resolve_type(type_to_resolve: Union['_NumberType', '_DatetimeType', '_TimespanType']) -> Optional[_KustoType]:
+    def __resolve_type(type_to_resolve: Union['NumberType', 'DatetimeType', 'TimespanType']) -> Optional[_KustoType]:
         # noinspection PyTypeChecker
         base_types = _get_base_types(type_to_resolve)
         possible_types = base_types & ({_KustoType.DATETIME, _KustoType.TIMESPAN} | _NUMBER_TYPES)
@@ -1003,7 +1003,7 @@ class _SubtractableColumn(_NumberColumn, _DatetimeColumn, _TimespanColumn):
             return None
         return next(iter(possible_types))
 
-    def __sub__(self, other: Union['_NumberType', '_DatetimeType', '_TimespanType']) -> Union['_NumberExpression', '_TimespanExpression', 'AnyExpression']:
+    def __sub__(self, other: Union['NumberType', 'DatetimeType', 'TimespanType']) -> Union['_NumberExpression', '_TimespanExpression', 'AnyExpression']:
         resolved_type = self.__resolve_type(other)
         if resolved_type == _KustoType.DATETIME:
             # Subtracting a datetime can only result in a timespan
@@ -1016,7 +1016,7 @@ class _SubtractableColumn(_NumberColumn, _DatetimeColumn, _TimespanColumn):
         # noinspection PyTypeChecker
         return BaseExpression.base_binary_op(self, ' - ', other, resolved_type)
 
-    def __rsub__(self, other: Union['_NumberType', '_DatetimeType', '_TimespanType']) -> Union['_NumberExpression', '_TimespanExpression', 'AnyExpression']:
+    def __rsub__(self, other: Union['NumberType', 'DatetimeType', 'TimespanType']) -> Union['_NumberExpression', '_TimespanExpression', 'AnyExpression']:
         resolved_type = self.__resolve_type(other)
         if resolved_type == _KustoType.DATETIME:
             # Subtracting from a datetime can result in either a datetime or a timespan
@@ -1056,7 +1056,7 @@ class _ColumnToType(BaseExpression):
         super().__init__(KQL(f"{col.kql} to typeof({kusto_type.primary_name})"))
 
 
-def _to_kql(obj: _ExpressionType, parentheses: bool = False) -> KQL:
+def _to_kql(obj: ExpressionType, parentheses: bool = False) -> KQL:
     """
     Convert the given expression to KQL. If this is a subexpression of a greater expression, neighboring operators might
     take precedence over operators included in this expression, causing an incorrect evaluation order. This might not be a concern, if
@@ -1072,7 +1072,7 @@ def _to_kql(obj: _ExpressionType, parentheses: bool = False) -> KQL:
     return _kql_converter.for_obj(obj)
 
 
-def _expression_to_type(expression: _ExpressionType, type_registrar: _TypeRegistrar, fallback_type: Any) -> Any:
+def _expression_to_type(expression: ExpressionType, type_registrar: _TypeRegistrar, fallback_type: Any) -> Any:
     types = set(type_registrar.registry[base_type] for base_type in _plain_expression.get_base_types(expression))
     return next(iter(types)) if len(types) == 1 else fallback_type
 
diff --git a/pykusto/_src/functions.py b/pykusto/_src/functions.py
index 007968a..6759cba 100644
--- a/pykusto/_src/functions.py
+++ b/pykusto/_src/functions.py
@@ -2,9 +2,9 @@ from itertools import chain
 from typing import Union
 
 from .enums import Kind
-from .expressions import _AnyTypeColumn, _NumberType, _NumberExpression, _TimespanType, \
-    _DatetimeExpression, _TimespanExpression, _ArrayType, _DynamicType, _DatetimeType, BaseExpression, _BooleanType, \
-    _ExpressionType, _StringType, _StringExpression, _BooleanExpression, \
+from .expressions import _AnyTypeColumn, NumberType, _NumberExpression, TimespanType, \
+    _DatetimeExpression, _TimespanExpression, ArrayType, DynamicType, DatetimeType, BaseExpression, BooleanType, \
+    ExpressionType, StringType, _StringExpression, _BooleanExpression, \
     _NumberAggregationExpression, _MappingAggregationExpression, _ArrayAggregationExpression, _to_kql, _DynamicExpression, \
     _ArrayExpression, _ColumnToType, BaseColumn, AnyExpression, _AnyAggregationExpression, _MappingExpression
 from .kql_converters import KQL
@@ -21,21 +21,21 @@ class Functions:
     # Scalar functions
 
     @staticmethod
-    def acos(expr: _NumberType) -> _NumberExpression:
+    def acos(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/acosfunction
         """
         return expr.acos()
 
     @staticmethod
-    def ago(expr: _TimespanType) -> _DatetimeExpression:
+    def ago(expr: TimespanType) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/agofunction
         """
         return _TimespanExpression.ago(expr)
 
     @staticmethod
-    def array_length(expr: _ArrayType) -> _NumberExpression:
+    def array_length(expr: ArrayType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/arraylengthfunction
         """
@@ -66,7 +66,7 @@ class Functions:
     #
     #
     @staticmethod
-    def bag_keys(expr: _DynamicType):
+    def bag_keys(expr: DynamicType):
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/bagkeysfunction
         """
@@ -81,8 +81,8 @@ class Functions:
     # def beta_pdf(self): return
 
     @staticmethod
-    def bin(expr: Union[_NumberType, _DatetimeType, _TimespanType],
-            round_to: Union[_NumberType, _TimespanType]) -> BaseExpression:
+    def bin(expr: Union[NumberType, DatetimeType, TimespanType],
+            round_to: Union[NumberType, TimespanType]) -> BaseExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/binfunction\n
         Refers only to bin() as part of summarize by bin(...),
@@ -94,37 +94,37 @@ class Functions:
         return expr.bin(round_to)
 
     @staticmethod
-    def bin_at(expr: Union[_NumberType, _DatetimeType, _TimespanType],
-               bin_size: Union[_NumberType, _TimespanType],
-               fixed_point: Union[_NumberType, _DatetimeType, _TimespanType]) -> BaseExpression:
+    def bin_at(expr: Union[NumberType, DatetimeType, TimespanType],
+               bin_size: Union[NumberType, TimespanType],
+               fixed_point: Union[NumberType, DatetimeType, TimespanType]) -> BaseExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/binatfunction
         """
         return expr.bin_at(bin_size, fixed_point)
 
     @staticmethod
-    def bin_auto(expr: Union[_NumberType, _DatetimeType, _TimespanType]) -> BaseExpression:
+    def bin_auto(expr: Union[NumberType, DatetimeType, TimespanType]) -> BaseExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/bin-autofunction
         """
         return expr.bin_auto()
 
     @staticmethod
-    def all_of(*predicates: _BooleanType) -> _BooleanExpression:
+    def all_of(*predicates: BooleanType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/logicaloperators
         """
         return _BooleanExpression(KQL(' and '.join(_to_kql(c, True) for c in predicates)))
 
     @staticmethod
-    def any_of(*predicates: _BooleanType) -> _BooleanExpression:
+    def any_of(*predicates: BooleanType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/logicaloperators
         """
         return _BooleanExpression(KQL(' or '.join(_to_kql(c, True) for c in predicates)))
 
     @staticmethod
-    def not_of(predicate: _BooleanType) -> _BooleanExpression:
+    def not_of(predicate: BooleanType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/logicaloperators
         Note that using the Python 'not' does not have the desired effect, because unfortunately its behavior cannot be overridden.
@@ -149,7 +149,7 @@ class Functions:
     # def binary_xor(self): return
 
     @staticmethod
-    def case(predicate: _BooleanType, val: _ExpressionType, *args: Union[_BooleanType, _ExpressionType]) -> AnyExpression:
+    def case(predicate: BooleanType, val: ExpressionType, *args: Union[BooleanType, ExpressionType]) -> AnyExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/casefunction
         """
@@ -157,7 +157,7 @@ class Functions:
         return AnyExpression(KQL(f"case({_to_kql(predicate)}, {_to_kql(val)}, {', '.join(_to_kql(arg) for arg in args)})"))
 
     @staticmethod
-    def ceiling(expr: _NumberType) -> _NumberExpression:
+    def ceiling(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/ceilingfunction
         """
@@ -171,7 +171,7 @@ class Functions:
     #
 
     @staticmethod
-    def cos(expr: _NumberType) -> _NumberExpression:
+    def cos(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/cosfunction
         """
@@ -180,7 +180,7 @@ class Functions:
     # def cot(self): return
 
     @staticmethod
-    def count_of(text: _StringType, search: _StringType, kind: Kind = Kind.NORMAL) -> _NumberExpression:
+    def count_of(text: StringType, search: StringType, kind: Kind = Kind.NORMAL) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/countoffunction
         """
@@ -229,28 +229,28 @@ class Functions:
     # def degrees(self): return
 
     @staticmethod
-    def end_of_day(expr: _DatetimeExpression, offset: _NumberType = None) -> _DatetimeExpression:
+    def end_of_day(expr: _DatetimeExpression, offset: NumberType = None) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/endofdayfunction
         """
         return expr.end_of_day(offset)
 
     @staticmethod
-    def end_of_month(expr: _DatetimeType, offset: _NumberType = None) -> _DatetimeExpression:
+    def end_of_month(expr: DatetimeType, offset: NumberType = None) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/endofmonthfunction
         """
         return expr.end_of_month(offset)
 
     @staticmethod
-    def end_of_week(expr: _DatetimeType, offset: _NumberType = None) -> _DatetimeExpression:
+    def end_of_week(expr: DatetimeType, offset: NumberType = None) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/endofweekfunction
         """
         return expr.end_of_week(offset)
 
     @staticmethod
-    def end_of_year(expr: _DatetimeType, offset: _NumberType = None) -> _DatetimeExpression:
+    def end_of_year(expr: DatetimeType, offset: NumberType = None) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/endofyearfunction
         """
@@ -259,21 +259,21 @@ class Functions:
     # def estimate_data_size(self): return
 
     @staticmethod
-    def exp(expr: _NumberType) -> _NumberExpression:
+    def exp(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/exp-function
         """
         return expr.exp()
 
     @staticmethod
-    def exp10(expr: _NumberType) -> _NumberExpression:
+    def exp10(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/exp10-function
         """
         return expr.exp10()
 
     @staticmethod
-    def exp2(expr: _NumberType) -> _NumberExpression:
+    def exp2(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/exp2-function
         """
@@ -294,22 +294,22 @@ class Functions:
     # def extractjson(self): return
 
     @staticmethod
-    def floor(expr: Union[_NumberType, _DatetimeType],
-              round_to: Union[_NumberType, _TimespanType]) -> Union[_NumberExpression, _DatetimeExpression]:
+    def floor(expr: Union[NumberType, DatetimeType],
+              round_to: Union[NumberType, TimespanType]) -> Union[_NumberExpression, _DatetimeExpression]:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/floorfunction
         """
         return expr.floor(round_to)
 
     @staticmethod
-    def format_datetime(expr: _DatetimeExpression, format_string: _StringType) -> _StringExpression:
+    def format_datetime(expr: _DatetimeExpression, format_string: StringType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/format-datetimefunction
         """
         return expr.format_datetime(format_string)
 
     @staticmethod
-    def format_timespan(expr: _TimespanType, format_string: _StringType) -> _StringExpression:
+    def format_timespan(expr: TimespanType, format_string: StringType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/format-timespanfunction
         """
@@ -318,21 +318,21 @@ class Functions:
     # def gamma(self): return
 
     @staticmethod
-    def get_month(expr: _DatetimeType) -> _NumberExpression:
+    def get_month(expr: DatetimeType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/getmonthfunction
         """
         return expr.get_month()
 
     @staticmethod
-    def get_type(expr: _ExpressionType) -> _StringExpression:
+    def get_type(expr: ExpressionType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/gettypefunction
         """
         return expr.get_type()
 
     @staticmethod
-    def get_year(expr: _DatetimeType) -> _NumberExpression:
+    def get_year(expr: DatetimeType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/getyearfunction
         """
@@ -346,21 +346,21 @@ class Functions:
         return expr.__hash__(mod)
 
     @staticmethod
-    def hash_sha256(expr: _ExpressionType) -> _StringExpression:
+    def hash_sha256(expr: ExpressionType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/sha256hashfunction
         """
         return expr.hash_sha256()
 
     @staticmethod
-    def hour_of_day(expr: _DatetimeType) -> _NumberExpression:
+    def hour_of_day(expr: DatetimeType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/hourofdayfunction
         """
         return expr.hour_of_day()
 
     @staticmethod
-    def iff(predicate: _BooleanType, if_true: _ExpressionType, if_false: _ExpressionType) -> BaseExpression:
+    def iff(predicate: BooleanType, if_true: ExpressionType, if_false: ExpressionType) -> BaseExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/ifffunction
         """
@@ -382,7 +382,7 @@ class Functions:
         )
 
     @staticmethod
-    def iif(predicate: _BooleanType, if_true: _ExpressionType, if_false: _ExpressionType) -> BaseExpression:
+    def iif(predicate: BooleanType, if_true: ExpressionType, if_false: ExpressionType) -> BaseExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/iiffunction
         """
@@ -405,21 +405,21 @@ class Functions:
         return _DatetimeExpression(KQL('ingestion_time()'))
 
     @staticmethod
-    def is_empty(expr: _ExpressionType) -> _BooleanExpression:
+    def is_empty(expr: ExpressionType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/isemptyfunction
         """
         return expr.is_empty()
 
     @staticmethod
-    def is_finite(expr: _NumberType) -> _BooleanExpression:
+    def is_finite(expr: NumberType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/isfinitefunction
         """
         return expr.isfinite()
 
     @staticmethod
-    def is_inf(expr: _NumberType) -> _BooleanExpression:
+    def is_inf(expr: NumberType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/isinffunction
         """
@@ -433,68 +433,68 @@ class Functions:
         return expr.is_nan()
 
     @staticmethod
-    def is_not_empty(expr: _ExpressionType) -> _BooleanExpression:
+    def is_not_empty(expr: ExpressionType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/isnotemptyfunction
         """
         return expr.is_not_empty()
 
     @staticmethod
-    def is_not_null(expr: _ExpressionType) -> _BooleanExpression:
+    def is_not_null(expr: ExpressionType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/isnotnullfunction
         """
         return expr.is_not_null()
 
     @staticmethod
-    def is_null(expr: _ExpressionType) -> _BooleanExpression:
+    def is_null(expr: ExpressionType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/isnullfunction
         """
         return expr.is_null()
 
     @staticmethod
-    def is_utf8(expr: _StringType) -> _BooleanExpression:
+    def is_utf8(expr: StringType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/isutf8
         """
         return expr.is_utf8()
 
     @staticmethod
-    def log(expr: _NumberType) -> _NumberExpression:
+    def log(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/log-function
         """
         return expr.log()
 
     @staticmethod
-    def log10(expr: _NumberType) -> _NumberExpression:
+    def log10(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/log10-function
         """
         return expr.log10()
 
     @staticmethod
-    def log2(expr: _NumberType) -> _NumberExpression:
+    def log2(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/log2-function
         """
         return expr.log2()
 
     @staticmethod
-    def log_gamma(expr: _NumberType) -> _NumberExpression:
+    def log_gamma(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/loggammafunction
         """
         return expr.log_gamma()
 
     @staticmethod
-    def make_datetime(year: _NumberType,
-                      month: _NumberType,
-                      day: _NumberType,
-                      hour: _NumberType = None,
-                      minute: _NumberType = None,
-                      second: _NumberType = None) -> _DatetimeExpression:
+    def make_datetime(year: NumberType,
+                      month: NumberType,
+                      day: NumberType,
+                      hour: NumberType = None,
+                      minute: NumberType = None,
+                      second: NumberType = None) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/make-datetimefunction
         """
@@ -504,7 +504,7 @@ class Functions:
         return _DatetimeExpression(KQL(res))
 
     @staticmethod
-    def make_string(*args: Union[_NumberType, _ArrayType]) -> _StringExpression:
+    def make_string(*args: Union[NumberType, ArrayType]) -> _StringExpression:
         """
         print str = make_string(dynamic([75, 117, 115]), 116, 111)
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/makestringfunction
@@ -524,7 +524,7 @@ class Functions:
     # def min_of(self): return
 
     @staticmethod
-    def month_of_year(date: _DatetimeType) -> _NumberExpression:
+    def month_of_year(date: DatetimeType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/monthofyearfunction
         """
@@ -538,7 +538,7 @@ class Functions:
         raise NotImplemented  # pragma: no cover
 
     @staticmethod
-    def now(offset: _TimespanType = None) -> _DatetimeExpression:
+    def now(offset: TimespanType = None) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/nowfunction
         """
@@ -547,7 +547,7 @@ class Functions:
         return _DatetimeExpression(KQL('now()'))
 
     @staticmethod
-    def pack(**kwargs: _ExpressionType) -> _MappingExpression:
+    def pack(**kwargs: ExpressionType) -> _MappingExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/packfunction
         """
@@ -561,14 +561,14 @@ class Functions:
         return _MappingExpression(KQL("pack_all()"))
 
     @staticmethod
-    def pack_array(*elements: _ExpressionType) -> '_ArrayExpression':
+    def pack_array(*elements: ExpressionType) -> '_ArrayExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/packarrayfunction
         """
         return _ArrayExpression(KQL(f'pack_array({", ".join(_to_kql(e) for e in elements)})'))
 
     @staticmethod
-    def pack_dictionary(**kwargs: _ExpressionType) -> _MappingExpression:
+    def pack_dictionary(**kwargs: ExpressionType) -> _MappingExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/packdictionaryfunction
         """
@@ -582,7 +582,7 @@ class Functions:
     # def parse_ipv4(self): return
 
     @staticmethod
-    def parse_json(expr: Union[_StringType, _DynamicType]) -> _DynamicExpression:
+    def parse_json(expr: Union[StringType, DynamicType]) -> _DynamicExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/parsejsonfunction
         """
@@ -620,7 +620,7 @@ class Functions:
         raise NotImplemented  # pragma: no cover
 
     @staticmethod
-    def pow(expr1: _NumberType, expr2: _NumberType) -> _NumberExpression:
+    def pow(expr1: NumberType, expr2: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/powfunction
         """
@@ -645,7 +645,7 @@ class Functions:
     # def reverse(self): return
 
     @staticmethod
-    def round(expr: _NumberType, precision: _NumberType = None) -> _NumberExpression:
+    def round(expr: NumberType, precision: NumberType = None) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/roundfunction
         """
@@ -744,98 +744,98 @@ class Functions:
     # def set_union(self): return
 
     @staticmethod
-    def set_has_element(array: _ArrayType, value: _ExpressionType) -> _BooleanExpression:
+    def set_has_element(array: ArrayType, value: ExpressionType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/sethaselementfunction
         """
         return _BooleanExpression(KQL(f'set_has_element({_to_kql(array)}, {_to_kql(value)})'))
 
     @staticmethod
-    def set_difference(array1: _ArrayType, array2: _ArrayType, *more_arrays: _ArrayType) -> _ArrayExpression:
+    def set_difference(array1: ArrayType, array2: ArrayType, *more_arrays: ArrayType) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/setdifferencefunction
         """
         return _ArrayExpression(KQL(f'set_difference({_to_kql(array1)}, {", ".join(_to_kql(a) for a in chain([array2], more_arrays))})'))
 
     @staticmethod
-    def set_intersect(array1: _ArrayType, array2: _ArrayType, *more_arrays: _ArrayType) -> _ArrayExpression:
+    def set_intersect(array1: ArrayType, array2: ArrayType, *more_arrays: ArrayType) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/setintersectfunction
         """
         return _ArrayExpression(KQL(f'set_intersect({_to_kql(array1)}, {", ".join(_to_kql(a) for a in chain([array2], more_arrays))})'))
 
     @staticmethod
-    def set_union(array1: _ArrayType, array2: _ArrayType, *more_arrays: _ArrayType) -> _ArrayExpression:
+    def set_union(array1: ArrayType, array2: ArrayType, *more_arrays: ArrayType) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/setunionfunction
         """
         return _ArrayExpression(KQL(f'set_union({_to_kql(array1)}, {", ".join(_to_kql(a) for a in chain([array2], more_arrays))})'))
 
     @staticmethod
-    def array_concat(array1: _ArrayType, array2: _ArrayType, *more_arrays: _ArrayType) -> _ArrayExpression:
+    def array_concat(array1: ArrayType, array2: ArrayType, *more_arrays: ArrayType) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/arrayconcatfunction
         """
         return _ArrayExpression(KQL(f'array_concat({_to_kql(array1)}, {", ".join(_to_kql(a) for a in chain([array2], more_arrays))})'))
 
     @staticmethod
-    def array_iif(condition_array: _ArrayType, if_true: _ArrayType, if_false: _ArrayType) -> _ArrayExpression:
+    def array_iif(condition_array: ArrayType, if_true: ArrayType, if_false: ArrayType) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/arrayifffunction
         """
         return _ArrayExpression(KQL(f'array_iif({_to_kql(condition_array)}, {_to_kql(if_true)}, {_to_kql(if_false)})'))
 
     @staticmethod
-    def array_index_of(array: _ArrayType, value: _ExpressionType) -> _NumberExpression:
+    def array_index_of(array: ArrayType, value: ExpressionType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/arrayindexoffunction
         """
         return _NumberExpression(KQL(f'array_index_of({_to_kql(array)}, {_to_kql(value)})'))
 
     @staticmethod
-    def array_rotate_left(array: _ArrayType, rotate_count: _NumberType) -> _ArrayExpression:
+    def array_rotate_left(array: ArrayType, rotate_count: NumberType) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/array_rotate_leftfunction
         """
         return _ArrayExpression(KQL(f'array_rotate_left({_to_kql(array)}, {_to_kql(rotate_count)})'))
 
     @staticmethod
-    def array_rotate_right(array: _ArrayType, rotate_count: _NumberType) -> _ArrayExpression:
+    def array_rotate_right(array: ArrayType, rotate_count: NumberType) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/array_rotate_rightfunction
         """
         return _ArrayExpression(KQL(f'array_rotate_right({_to_kql(array)}, {_to_kql(rotate_count)})'))
 
     @staticmethod
-    def array_shift_left(array: _ArrayType, shift_count: _NumberType, fill_value: _ExpressionType = None) -> _ArrayExpression:
+    def array_shift_left(array: ArrayType, shift_count: NumberType, fill_value: ExpressionType = None) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/array_shift_leftfunction
         """
         return _ArrayExpression(KQL(f'array_shift_left({_to_kql(array)}, {_to_kql(shift_count)}{"" if fill_value is None else ", " + _to_kql(fill_value)})'))
 
     @staticmethod
-    def array_shift_right(array: _ArrayType, shift_count: _NumberType, fill_value: _ExpressionType = None) -> _ArrayExpression:
+    def array_shift_right(array: ArrayType, shift_count: NumberType, fill_value: ExpressionType = None) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/array_shift_rightfunction
         """
         return _ArrayExpression(KQL(f'array_shift_right({_to_kql(array)}, {_to_kql(shift_count)}{"" if fill_value is None else ", " + _to_kql(fill_value)})'))
 
     @staticmethod
-    def array_slice(array: _ArrayType, start: _NumberType, end: _NumberType) -> _ArrayExpression:
+    def array_slice(array: ArrayType, start: NumberType, end: NumberType) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/arrayslicefunction
         """
         return _ArrayExpression(KQL(f'array_slice({_to_kql(array)}, {_to_kql(start)}, {_to_kql(end)})'))
 
     @staticmethod
-    def array_split(array: _ArrayType, indices: Union[_NumberType, _ArrayType]) -> _ArrayExpression:
+    def array_split(array: ArrayType, indices: Union[NumberType, ArrayType]) -> _ArrayExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/arraysplitfunction
         """
         return _ArrayExpression(KQL(f'array_split({_to_kql(array)}, {_to_kql(indices)})'))
 
     @staticmethod
-    def sign(expr: _NumberType) -> _NumberExpression:
+    def sign(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/signfunction
         """
@@ -845,49 +845,49 @@ class Functions:
     #
     #
     @staticmethod
-    def split(string: _StringType, delimiter: _StringType, requested_index: _NumberType = None) -> '_ArrayExpression':
+    def split(string: StringType, delimiter: StringType, requested_index: NumberType = None) -> '_ArrayExpression':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/splitfunction
         """
         return _StringExpression(_to_kql(string)).split(delimiter, requested_index)
 
     @staticmethod
-    def sqrt(expr: _NumberType) -> _NumberExpression:
+    def sqrt(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/sqrtfunction
         """
         return _NumberExpression(KQL(f'sqrt({_to_kql(expr)})'))
 
     @staticmethod
-    def start_of_day(expr: _DatetimeType, offset: _NumberType = None) -> _DatetimeExpression:
+    def start_of_day(expr: DatetimeType, offset: NumberType = None) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/startofdayfunction
         """
         return expr.start_of_day(offset)
 
     @staticmethod
-    def start_of_month(expr: _DatetimeType, offset: _NumberType = None) -> _DatetimeExpression:
+    def start_of_month(expr: DatetimeType, offset: NumberType = None) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/startofmonthfunction
         """
         return expr.start_of_month(offset)
 
     @staticmethod
-    def start_of_week(expr: _DatetimeType, offset: _NumberType = None) -> _DatetimeExpression:
+    def start_of_week(expr: DatetimeType, offset: NumberType = None) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/startofweekfunction
         """
         return expr.start_of_week(offset)
 
     @staticmethod
-    def start_of_year(expr: _DatetimeType, offset: _NumberType = None) -> _DatetimeExpression:
+    def start_of_year(expr: DatetimeType, offset: NumberType = None) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/startofyearfunction
         """
         return expr.start_of_year(offset)
 
     @staticmethod
-    def strcat(*strings: _StringType) -> _StringExpression:
+    def strcat(*strings: StringType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/strcatfunction
         """
@@ -896,14 +896,14 @@ class Functions:
         return _StringExpression(KQL(f"strcat({', '.join(_to_kql(s) for s in strings)})"))
 
     @staticmethod
-    def strcat_array(expr: _ArrayType, delimiter: _StringType) -> _StringExpression:
+    def strcat_array(expr: ArrayType, delimiter: StringType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/strcat-arrayfunction
         """
         return _StringExpression(KQL(f'strcat_array({_to_kql(expr)}, {_to_kql(delimiter)})'))
 
     @staticmethod
-    def strcat_delim(delimiter: _StringType, expr1: _StringType, expr2: _StringType, *expressions: _StringType) -> _StringExpression:
+    def strcat_delim(delimiter: StringType, expr1: StringType, expr2: StringType, *expressions: StringType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/strcat-delimfunction
         """
@@ -913,30 +913,30 @@ class Functions:
         return _StringExpression(KQL(res + ')'))
 
     @staticmethod
-    def strcmp(expr1: _StringType, expr2: _StringType) -> _NumberExpression:
+    def strcmp(expr1: StringType, expr2: StringType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/strcmpfunction
         """
         return _NumberExpression(KQL(f'strcmp({_to_kql(expr1)}, {_to_kql(expr2)})'))
 
     @staticmethod
-    def string_size(expr: _StringType) -> _NumberExpression:
+    def string_size(expr: StringType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/stringsizefunction
         """
         return _StringExpression(expr).string_size()
 
     @staticmethod
-    def strlen(expr: _StringType) -> _NumberExpression:
+    def strlen(expr: StringType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/strlenfunction
         """
         return _NumberExpression(KQL(f'strlen({_to_kql(expr)})'))
 
     @staticmethod
-    def strrep(expr: _StringType,
-               multiplier: _NumberType,
-               delimiter: _StringType = None) -> _StringExpression:
+    def strrep(expr: StringType,
+               multiplier: NumberType,
+               delimiter: StringType = None) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/strrepfunction
         """
@@ -947,7 +947,7 @@ class Functions:
         return _StringExpression(KQL(res))
 
     @staticmethod
-    def substring(expr: _StringType, start_index: _NumberType, length: _NumberType = None) -> _StringExpression:
+    def substring(expr: StringType, start_index: NumberType, length: NumberType = None) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/substringfunction
         """
@@ -961,35 +961,35 @@ class Functions:
     # def tdigest_merge(self): return
 
     @staticmethod
-    def to_bool(expr: _ExpressionType) -> _BooleanExpression:
+    def to_bool(expr: ExpressionType) -> _BooleanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/toboolfunction
         """
         return _BooleanExpression(KQL(f'tobool({_to_kql(expr)})'))
 
     @staticmethod
-    def to_datetime(expr: _StringType) -> _DatetimeExpression:
+    def to_datetime(expr: StringType) -> _DatetimeExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/todatetimefunction
         """
         return _DatetimeExpression(KQL(f'todatetime({_to_kql(expr)})'))
 
     @staticmethod
-    def to_decimal(expr: _NumberType) -> _NumberExpression:
+    def to_decimal(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/todecimalfunction
         """
         return _NumberExpression(KQL(f"todecimal({_to_kql(expr)})"))
 
     @staticmethod
-    def to_double(expr: _NumberType) -> _NumberExpression:
+    def to_double(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/todoublefunction
         """
         return _NumberExpression(KQL(f"todouble({_to_kql(expr)})"))
 
     @staticmethod
-    def to_dynamic(json: _StringType) -> _DynamicExpression:
+    def to_dynamic(json: StringType) -> _DynamicExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/todynamicfunction
         """
@@ -1003,56 +1003,56 @@ class Functions:
         raise NotImplemented  # pragma: no cover
 
     @staticmethod
-    def to_hex(expr1: _NumberType, expr2: _NumberType = None) -> _StringExpression:
+    def to_hex(expr1: NumberType, expr2: NumberType = None) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/tohexfunction
         """
         return _StringExpression(KQL(f'tohex({_to_kql(expr1)})' if expr2 is None else 'tohex({to_kql(expr1)}, {to_kql(expr2)})'))
 
     @staticmethod
-    def to_int(expr: _NumberType) -> _NumberExpression:
+    def to_int(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/tointfunction
         """
         return _NumberExpression(KQL(f"toint({_to_kql(expr)})"))
 
     @staticmethod
-    def to_long(expr: _NumberType) -> _NumberExpression:
+    def to_long(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/tolongfunction
         """
         return _NumberExpression(KQL(f"tolong({_to_kql(expr)})"))
 
     @staticmethod
-    def to_lower(expr: _StringType) -> _StringExpression:
+    def to_lower(expr: StringType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/tolowerfunction
         """
         return expr.lower()
 
     @staticmethod
-    def to_real(expr: _NumberType) -> _NumberExpression:
+    def to_real(expr: NumberType) -> _NumberExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/todoublefunction
         """
         return _NumberExpression(KQL(f"toreal({_to_kql(expr)})"))
 
     @staticmethod
-    def to_string(expr: _ExpressionType):
+    def to_string(expr: ExpressionType):
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/tostringfunction
         """
         return expr.to_string()
 
     @staticmethod
-    def to_timespan(expr: _StringType) -> _TimespanExpression:
+    def to_timespan(expr: StringType) -> _TimespanExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/totimespanfunction
         """
         return _TimespanExpression(KQL(f"totimespan({_to_kql(expr)})"))
 
     @staticmethod
-    def to_upper(expr: _StringType) -> _StringExpression:
+    def to_upper(expr: StringType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/toupperfunction
         """
@@ -1067,7 +1067,7 @@ class Functions:
     # def treepath(self): return
 
     @staticmethod
-    def trim(regex: _StringType, text: _StringType) -> _StringExpression:
+    def trim(regex: StringType, text: StringType) -> _StringExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/trimfunction
         """
@@ -1113,42 +1113,42 @@ class Functions:
     # -----------------------------------------------------
 
     @staticmethod
-    def any(*args: _ExpressionType) -> _AnyAggregationExpression:
+    def any(*args: ExpressionType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/any-aggfunction
         """
         return _AnyAggregationExpression(KQL(f"any({', '.join(arg.kql for arg in args)})"))
 
     @staticmethod
-    def any_if(expr: _ExpressionType, predicate: _BooleanType) -> _AnyAggregationExpression:
+    def any_if(expr: ExpressionType, predicate: BooleanType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/anyif-aggfunction
         """
         return _AnyAggregationExpression(KQL(f"anyif({_to_kql(expr)}, {_to_kql(predicate)})"))
 
     @staticmethod
-    def arg_max(*args: _ExpressionType) -> _AnyAggregationExpression:
+    def arg_max(*args: ExpressionType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/arg-max-aggfunction
         """
         return _AnyAggregationExpression(KQL(f"arg_max({', '.join(arg.kql for arg in args)})"))
 
     @staticmethod
-    def arg_min(*args: _ExpressionType) -> _AnyAggregationExpression:
+    def arg_min(*args: ExpressionType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/arg-min-aggfunction
         """
         return _AnyAggregationExpression(KQL(f"arg_min({', '.join(arg.kql for arg in args)})"))
 
     @staticmethod
-    def avg(expr: _ExpressionType) -> _NumberAggregationExpression:
+    def avg(expr: ExpressionType) -> _NumberAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/avg-aggfunction
         """
         return _NumberAggregationExpression(KQL(f'avg({_to_kql(expr)})'))
 
     @staticmethod
-    def avg_if(expr: _ExpressionType, predicate: _BooleanType) -> _NumberAggregationExpression:
+    def avg_if(expr: ExpressionType, predicate: BooleanType) -> _NumberAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/avgif-aggfunction
         """
@@ -1165,28 +1165,28 @@ class Functions:
         return _NumberAggregationExpression(KQL("count()" if col is None else f"count({col.kql})"))
 
     @staticmethod
-    def count_if(predicate: _BooleanType) -> _NumberAggregationExpression:
+    def count_if(predicate: BooleanType) -> _NumberAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/countif-aggfunction
         """
         return _NumberAggregationExpression(KQL(f'countif({_to_kql(predicate)})'))
 
     @staticmethod
-    def dcount(expr: _ExpressionType, accuracy: _NumberType = None) -> _NumberAggregationExpression:
+    def dcount(expr: ExpressionType, accuracy: NumberType = None) -> _NumberAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/dcount-aggfunction
         """
         return _NumberAggregationExpression(KQL(f'dcount({_to_kql(expr)})' if accuracy is None else f'dcount({_to_kql(expr)}, {_to_kql(accuracy)})'))
 
     @staticmethod
-    def dcount_if(expr: _ExpressionType, predicate: _BooleanType, accuracy: _NumberType = 0) -> _NumberAggregationExpression:
+    def dcount_if(expr: ExpressionType, predicate: BooleanType, accuracy: NumberType = 0) -> _NumberAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/dcountif-aggfunction
         """
         return _NumberAggregationExpression(KQL(f'dcountif({_to_kql(expr)}, {_to_kql(predicate)}, {_to_kql(accuracy)})'))
 
     @staticmethod
-    def make_bag(expr: _ExpressionType, max_size: _NumberType = None) -> _MappingAggregationExpression:
+    def make_bag(expr: ExpressionType, max_size: NumberType = None) -> _MappingAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/make-bag-aggfunction
         """
@@ -1195,7 +1195,7 @@ class Functions:
         return _MappingAggregationExpression(KQL(f'make_bag({_to_kql(expr)})'))
 
     @staticmethod
-    def make_list(expr: _ExpressionType, max_size: _NumberType = None) -> _ArrayAggregationExpression:
+    def make_list(expr: ExpressionType, max_size: NumberType = None) -> _ArrayAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/makelist-aggfunction
         """
@@ -1204,7 +1204,7 @@ class Functions:
         return _ArrayAggregationExpression(KQL(f'make_list({_to_kql(expr)})'))
 
     @staticmethod
-    def make_set(expr: _ExpressionType, max_size: _NumberType = None) -> _ArrayAggregationExpression:
+    def make_set(expr: ExpressionType, max_size: NumberType = None) -> _ArrayAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/makeset-aggfunction
         """
@@ -1213,84 +1213,84 @@ class Functions:
         return _ArrayAggregationExpression(KQL(f'make_set({_to_kql(expr)})'))
 
     @staticmethod
-    def max(expr: _ExpressionType) -> _AnyAggregationExpression:
+    def max(expr: ExpressionType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/makeset-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'max({_to_kql(expr)})'))
 
     @staticmethod
-    def min(expr: _ExpressionType) -> _AnyAggregationExpression:
+    def min(expr: ExpressionType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/min-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'min({_to_kql(expr)})'))
 
     @staticmethod
-    def max_if(expr: _ExpressionType, predicate: _BooleanType) -> _AnyAggregationExpression:
+    def max_if(expr: ExpressionType, predicate: BooleanType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/maxif-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'maxif({_to_kql(expr)}, {_to_kql(predicate)})'))
 
     @staticmethod
-    def min_if(expr: _ExpressionType, predicate: _BooleanType) -> _AnyAggregationExpression:
+    def min_if(expr: ExpressionType, predicate: BooleanType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/minif-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'minif({_to_kql(expr)}, {_to_kql(predicate)})'))
 
     @staticmethod
-    def percentile(expr: _ExpressionType, per: _NumberType) -> _AnyAggregationExpression:
+    def percentile(expr: ExpressionType, per: NumberType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/percentiles-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'percentiles({_to_kql(expr)}, {_to_kql(per)})'))
 
     @staticmethod
-    def percentiles(expr: _ExpressionType, *pers: _NumberType) -> _AnyAggregationExpression:
+    def percentiles(expr: ExpressionType, *pers: NumberType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/percentiles-aggfunction
         """
         return _AnyAggregationExpression(KQL(f"percentiles({_to_kql(expr)}, {', '.join(str(_to_kql(per)) for per in pers)})"))
 
     @staticmethod
-    def percentiles_array(expr: _ExpressionType, *pers: _NumberType) -> _ArrayAggregationExpression:
+    def percentiles_array(expr: ExpressionType, *pers: NumberType) -> _ArrayAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/percentiles-aggfunction
         """
         return _ArrayAggregationExpression(KQL(f"percentiles_array({_to_kql(expr)}, {', '.join(str(_to_kql(per)) for per in pers)})"))
 
     @staticmethod
-    def stdev(expr: _ExpressionType) -> _AnyAggregationExpression:
+    def stdev(expr: ExpressionType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/stdev-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'stdev({_to_kql(expr)})'))
 
     @staticmethod
-    def stdevif(expr: _ExpressionType, predicate: _BooleanType) -> _AnyAggregationExpression:
+    def stdevif(expr: ExpressionType, predicate: BooleanType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/stdevif-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'stdevif({_to_kql(expr)}, {_to_kql(predicate)})'))
 
     @staticmethod
-    def stdevp(expr: _ExpressionType) -> _AnyAggregationExpression:
+    def stdevp(expr: ExpressionType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/stdevp-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'stdevp({_to_kql(expr)})'))
 
     @staticmethod
-    def sum(expr: _ExpressionType) -> _AnyAggregationExpression:
+    def sum(expr: ExpressionType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/sum-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'sum({_to_kql(expr)})'))
 
     @staticmethod
-    def sum_if(expr: _ExpressionType, predicate: _BooleanType) -> _AnyAggregationExpression:
+    def sum_if(expr: ExpressionType, predicate: BooleanType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/sumif-aggfunction
         """
@@ -1304,21 +1304,21 @@ class Functions:
     #     return
 
     @staticmethod
-    def variance(expr: _ExpressionType) -> _AnyAggregationExpression:
+    def variance(expr: ExpressionType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/variance-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'variance({_to_kql(expr)})'))
 
     @staticmethod
-    def variance_if(expr: _ExpressionType, predicate: _BooleanType) -> _AnyAggregationExpression:
+    def variance_if(expr: ExpressionType, predicate: BooleanType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/varianceif-aggfunction
         """
         return _AnyAggregationExpression(KQL(f'varianceif({_to_kql(expr)}, {_to_kql(predicate)})'))
 
     @staticmethod
-    def variancep(expr: _ExpressionType) -> _AnyAggregationExpression:
+    def variancep(expr: ExpressionType) -> _AnyAggregationExpression:
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/variancep-aggfunction
         """
diff --git a/pykusto/_src/query.py b/pykusto/_src/query.py
index eda217a..c0e3608 100644
--- a/pykusto/_src/query.py
+++ b/pykusto/_src/query.py
@@ -5,12 +5,12 @@ from os import linesep
 from types import FunctionType
 from typing import Tuple, List, Union, Optional
 
-from .client import _Table, KustoResponse, RetryConfig
+from .client import Table, KustoResponse, RetryConfig
 from .enums import Order, Nulls, JoinKind, Distribution, BagExpansion
-from .expressions import _BooleanType, _ExpressionType, AggregationExpression, _OrderedType, \
-    _StringType, _AssignmentBase, _AssignmentFromAggregationToColumn, _AssignmentToSingleColumn, _AnyTypeColumn, \
+from .expressions import BooleanType, ExpressionType, AggregationExpression, OrderedType, \
+    StringType, _AssignmentBase, _AssignmentFromAggregationToColumn, _AssignmentToSingleColumn, _AnyTypeColumn, \
     BaseExpression, \
-    _AssignmentFromColumnToColumn, AnyExpression, _to_kql, _expression_to_type, BaseColumn, _NumberType
+    _AssignmentFromColumnToColumn, AnyExpression, _to_kql, _expression_to_type, BaseColumn, NumberType
 from .functions import Functions as f
 from .kql_converters import KQL
 from .logger import _logger
@@ -20,7 +20,7 @@ from .udf import _stringify_python_func
 
 class Query:
     _head: Optional['Query']
-    _table: Optional[_Table]
+    _table: Optional[Table]
     _table_name: Optional[str]
 
     def __init__(self, head=None) -> None:
@@ -29,7 +29,7 @@ class Query:
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/best-practices
         """
         self._head = head if isinstance(head, Query) else None
-        self._table = head if isinstance(head, _Table) else None
+        self._table = head if isinstance(head, Table) else None
         self._table_name = head if isinstance(head, str) else None
 
     def __add__(self, other: 'Query') -> 'Query':
@@ -50,7 +50,7 @@ class Query:
             new_object._head = self._head.__deepcopy__(memo)
         return new_object
 
-    def where(self, *predicates: _BooleanType) -> 'Query':
+    def where(self, *predicates: BooleanType) -> 'Query':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/whereoperator
 
@@ -105,13 +105,13 @@ class Query:
         """
         return _CountQuery(self)
 
-    def sort_by(self, col: _OrderedType, order: Order = None, nulls: Nulls = None) -> '_SortQuery':
+    def sort_by(self, col: OrderedType, order: Order = None, nulls: Nulls = None) -> '_SortQuery':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/sortoperator
         """
         return _SortQuery(self, col, order, nulls)
 
-    def order_by(self, col: _OrderedType, order: Order = None, nulls: Nulls = None) -> '_SortQuery':
+    def order_by(self, col: OrderedType, order: Order = None, nulls: Nulls = None) -> '_SortQuery':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/orderoperator
         """
@@ -139,7 +139,7 @@ class Query:
         """
         return _JoinQuery(self, query, kind)
 
-    def project(self, *args: Union[_AssignmentBase, BaseExpression], **kwargs: _ExpressionType) -> '_ProjectQuery':
+    def project(self, *args: Union[_AssignmentBase, BaseExpression], **kwargs: ExpressionType) -> '_ProjectQuery':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/projectoperator
         """
@@ -154,7 +154,7 @@ class Query:
             assignments.append(_AssignmentFromColumnToColumn(_AnyTypeColumn(column_name), column))
         return _ProjectRenameQuery(self, assignments)
 
-    def project_away(self, *columns: _StringType) -> '_ProjectAwayQuery':
+    def project_away(self, *columns: StringType) -> '_ProjectAwayQuery':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/projectawayoperator
         """
@@ -172,7 +172,7 @@ class Query:
         """
         return _DistinctQuery(self, (_AnyTypeColumn(KQL("*")),))
 
-    def extend(self, *args: Union[BaseExpression, _AssignmentBase], **kwargs: _ExpressionType) -> '_ExtendQuery':
+    def extend(self, *args: Union[BaseExpression, _AssignmentBase], **kwargs: ExpressionType) -> '_ExtendQuery':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/extendoperator
         """
@@ -196,7 +196,7 @@ class Query:
 
     def mv_expand(
             self, *args: Union[BaseExpression, _AssignmentBase], bag_expansion: BagExpansion = None,
-            with_item_index: BaseColumn = None, limit: int = None, **kwargs: _ExpressionType
+            with_item_index: BaseColumn = None, limit: int = None, **kwargs: ExpressionType
     ) -> '_MvExpandQuery':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/mvexpandoperator
@@ -209,7 +209,7 @@ class Query:
     def custom(self, custom_query: str) -> '_CustomQuery':
         return _CustomQuery(self, custom_query)
 
-    def evaluate(self, plugin_name, *args: _ExpressionType, distribution: Distribution = None) -> '_EvaluateQuery':
+    def evaluate(self, plugin_name, *args: ExpressionType, distribution: Distribution = None) -> '_EvaluateQuery':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/evaluateoperator
         """
@@ -256,7 +256,7 @@ class Query:
         else:
             return KQL(f"{self._head._compile_all(use_full_table_name)} | {self._compile()}")
 
-    def get_table(self) -> _Table:
+    def get_table(self) -> Table:
         if self._head is None:
             return self._table
         else:
@@ -279,7 +279,7 @@ class Query:
             kql = KQL(kql.replace(" |", linesep + "|"))
         return kql
 
-    def execute(self, table: _Table = None, retry_config: RetryConfig = None) -> KustoResponse:
+    def execute(self, table: Table = None, retry_config: RetryConfig = None) -> KustoResponse:
         if self.get_table() is None:
             if table is None:
                 raise RuntimeError("No table supplied")
@@ -293,11 +293,11 @@ class Query:
         _logger.debug("Running query: " + rendered_query)
         return table.execute(rendered_query, retry_config)
 
-    def to_dataframe(self, table: _Table = None, retry_config: RetryConfig = None):
+    def to_dataframe(self, table: Table = None, retry_config: RetryConfig = None):
         return self.execute(table, retry_config).to_dataframe()
 
     @staticmethod
-    def _extract_assignments(*args: Union[_AssignmentBase, BaseExpression], **kwargs: _ExpressionType) -> List[_AssignmentBase]:
+    def _extract_assignments(*args: Union[_AssignmentBase, BaseExpression], **kwargs: ExpressionType) -> List[_AssignmentBase]:
         assignments: List[_AssignmentBase] = []
         for arg in args:
             if isinstance(arg, BaseExpression):
@@ -338,9 +338,9 @@ class _ProjectRenameQuery(Query):
 
 
 class _ProjectAwayQuery(Query):
-    _columns: Tuple[_StringType, ...]
+    _columns: Tuple[StringType, ...]
 
-    def __init__(self, head: 'Query', columns: Tuple[_StringType]) -> None:
+    def __init__(self, head: 'Query', columns: Tuple[StringType]) -> None:
         super().__init__(head)
         self._columns = columns
 
@@ -355,14 +355,14 @@ class _DistinctQuery(Query):
         super().__init__(head)
         self._columns = columns
 
-    def sample(self, number_of_values: _NumberType) -> '_SampleDistinctQuery':
+    def sample(self, number_of_values: NumberType) -> '_SampleDistinctQuery':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/sampledistinctoperator
         """
         assert len(self._columns) == 1, "sample-distinct supports only one column"
         return _SampleDistinctQuery(self._head, self._columns[0], number_of_values)
 
-    def top_hitters(self, number_of_values: _NumberType) -> '_TopHittersQuery':
+    def top_hitters(self, number_of_values: NumberType) -> '_TopHittersQuery':
         """
         https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/tophittersoperator
         """
@@ -374,10 +374,10 @@ class _DistinctQuery(Query):
 
 
 class _SampleDistinctQuery(Query):
-    _number_of_values: _NumberType
+    _number_of_values: NumberType
     _column: BaseColumn
 
-    def __init__(self, head: 'Query', column: BaseColumn, number_of_values: _NumberType) -> None:
+    def __init__(self, head: 'Query', column: BaseColumn, number_of_values: NumberType) -> None:
         super().__init__(head)
         self._column = column
         self._number_of_values = number_of_values
@@ -387,17 +387,17 @@ class _SampleDistinctQuery(Query):
 
 
 class _TopHittersQuery(Query):
-    _number_of_values: _NumberType
+    _number_of_values: NumberType
     _column: BaseColumn
-    _by_expression: Optional[_NumberType]
+    _by_expression: Optional[NumberType]
 
-    def __init__(self, head: 'Query', column: BaseColumn, number_of_values: _NumberType, by_expression: Optional[_NumberType] = None) -> None:
+    def __init__(self, head: 'Query', column: BaseColumn, number_of_values: NumberType, by_expression: Optional[NumberType] = None) -> None:
         super().__init__(head)
         self._column = column
         self._number_of_values = number_of_values
         self._by_expression = by_expression
 
-    def by(self, by_expression: _NumberType) -> '_TopHittersQuery':
+    def by(self, by_expression: NumberType) -> '_TopHittersQuery':
         assert self._by_expression is None, "duplicate 'by' clause"
         return _TopHittersQuery(self._head, self._column, self._number_of_values, by_expression)
 
@@ -417,9 +417,9 @@ class _ExtendQuery(Query):
 
 
 class _WhereQuery(Query):
-    _predicates: Tuple[_BooleanType, ...]
+    _predicates: Tuple[BooleanType, ...]
 
-    def __init__(self, head: Query, *predicates: _BooleanType):
+    def __init__(self, head: Query, *predicates: BooleanType):
         super(_WhereQuery, self).__init__(head)
         self._predicates = predicates
 
@@ -475,11 +475,11 @@ class _CountQuery(Query):
 
 class _OrderQueryBase(Query):
     class OrderSpec:
-        col: _OrderedType
+        col: OrderedType
         order: Order
         nulls: Nulls
 
-        def __init__(self, col: _OrderedType, order: Order, nulls: Nulls):
+        def __init__(self, col: OrderedType, order: Order, nulls: Nulls):
             self.col = col
             self.order = order
             self.nulls = nulls
@@ -487,13 +487,13 @@ class _OrderQueryBase(Query):
     _query_name: str
     _order_specs: List[OrderSpec]
 
-    def __init__(self, head: Query, query_name: str, col: _OrderedType, order: Order, nulls: Nulls):
+    def __init__(self, head: Query, query_name: str, col: OrderedType, order: Order, nulls: Nulls):
         super(_OrderQueryBase, self).__init__(head)
         self._query_name = query_name
         self._order_specs = []
         self.then_by(col, order, nulls)
 
-    def then_by(self, col: _OrderedType, order: Order = None, nulls: Nulls = None):
+    def then_by(self, col: OrderedType, order: Order = None, nulls: Nulls = None):
         self._order_specs.append(_OrderQueryBase.OrderSpec(col, order, nulls))
         return self
 
@@ -511,7 +511,7 @@ class _OrderQueryBase(Query):
 
 
 class _SortQuery(_OrderQueryBase):
-    def __init__(self, head: Query, col: _OrderedType, order: Order, nulls: Nulls):
+    def __init__(self, head: Query, col: OrderedType, order: Order, nulls: Nulls):
         super(_SortQuery, self).__init__(head, "sort", col, order, nulls)
 
 
@@ -637,10 +637,10 @@ class _CustomQuery(Query):
 
 class _EvaluateQuery(Query):
     _plugin_name: str
-    _args: Tuple[_ExpressionType]
+    _args: Tuple[ExpressionType]
     _distribution: Distribution
 
-    def __init__(self, head: Query, plugin_name: str, *args: _ExpressionType, distribution: Distribution = None):
+    def __init__(self, head: Query, plugin_name: str, *args: ExpressionType, distribution: Distribution = None):
         super().__init__(head)
         self._plugin_name = plugin_name
         self._args = args
diff --git a/test/test_base.py b/test/test_base.py
index 20c5063..7b19cc5 100644
--- a/test/test_base.py
+++ b/test/test_base.py
@@ -15,7 +15,7 @@ from azure.kusto.data._models import KustoResultTable, KustoResultRow
 from azure.kusto.data.response import KustoResponseDataSet
 
 # noinspection PyProtectedMember
-from pykusto._src.client import _Table
+from pykusto._src.client import Table
 # noinspection PyProtectedMember
 from pykusto._src.expressions import _NumberColumn, _BooleanColumn, _ArrayColumn, _MappingColumn, _StringColumn, _DatetimeColumn, _TimespanColumn, _DynamicColumn
 # noinspection PyProtectedMember
@@ -23,7 +23,7 @@ from pykusto._src.type_utils import _KustoType
 
 # Naming this variable "test_table" triggers the following bug: https://github.com/pytest-dev/pytest/issues/7378
 # noinspection PyTypeChecker
-mock_table = _Table(
+mock_table = Table(
     None, "mock_table",
     (
         _NumberColumn('numField'), _NumberColumn('numField2'), _NumberColumn('numField3'), _NumberColumn('numField4'), _NumberColumn('numField5'), _NumberColumn('numField6'),
diff --git a/test/test_client_fetch.py b/test/test_client_fetch.py
index 1be9aaf..3fe9d8c 100644
--- a/test/test_client_fetch.py
+++ b/test/test_client_fetch.py
@@ -4,7 +4,7 @@ from unittest.mock import patch
 
 from pykusto import PyKustoClient, Query
 # noinspection PyProtectedMember
-from pykusto._src.client import _Database
+from pykusto._src.client import Database
 # noinspection PyProtectedMember
 from pykusto._src.expressions import _StringColumn, _NumberColumn, _AnyTypeColumn, _BooleanColumn
 # noinspection PyProtectedMember
@@ -222,7 +222,7 @@ class TestClientFetch(TestBase):
         self.assertType(client.test_db['other_table']['foo'], _AnyTypeColumn)
         # Various utility methods
         db = client.get_database('test_db')
-        self.assertType(db, _Database)
+        self.assertType(db, Database)
         self.assertEqual('test_db', db.get_name())
         self.assertEqual(('test_db',), tuple(client.get_databases_names()))
         self.assertEqual(('mock_table', 'other_table'), tuple(client.test_db.get_table_names()))