class FiveTranConfig(BaseSettings)

@validator("endpoint")
def validate_endpoint(cls, value)

class Config()

def has_data_items(item: Dict) -> bool

class FivetranAPI()

def make_request(request: Callable[..., requests.Response],
                 url: str,
                 headers: Optional[Dict] = None,
                 params: Optional[Dict] = None,
                 **kwargs) -> Tuple[Dict, requests.Response]

def paginated_query(request: Callable[..., requests.Response],
                    url: str,
                    headers: Optional[Dict] = None,
                    params: Optional[Dict] = None,
                    **kwargs) -> Iterable[Dict]

def get_paginated_data_items(url: str,
                             headers: Optional[Dict] = None,
                             params: Optional[Dict] = None) -> List[Dict]

def get_tables(connector_id: str,
               limit: Optional[int] = None) -> List[TableMetadataResponse]

def get_columns(connector_id: str,
                limit: Optional[int] = None) -> List[ColumnMetadataResponse]

def get_schemas(connector_id: str,
                limit: Optional[int] = None) -> List[SchemaMetadataResponse]

def get_all_groups(limit: Optional[int] = None) -> List[GroupResponse]

def get_group_connectors(group_id: str,
                         limit: Optional[int] = None
                         ) -> List[ConnectorResponse]

def get_destination_metadata(
        destination_id: str) -> V1DestinationsDestinationIdGetResponse

def get_connector_metadata(
        connector_id: str) -> V1ConnectorsConnectorIdSchemasGetResponse

def get_source_table_column_metadata(
    connector_id: str, schema: str, table: str
) -> V1ConnectorsConnectorIdSchemasSchemaTablesTableColumnsGetResponse

def get_connectors() -> List[ConnectorResponse]

async def caller(semaphore: asyncio.Semaphore, func: Callable[..., T], *args,
                 **kwargs) -> T

def parallelize_http(semaphore)

class SourceDestinationDict(TypedDict)

class FivetranConnector(FivetranAPI)

def build_lineage()

def get_nodes_and_edges() -> Tuple[List[NodeTypes], List[Edge]]