From 2aa03a5493ee1fdd859d3451498cb5cff6d85d70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sergio=20G=C3=B3mez=20Villamor?= Date: Wed, 29 Jan 2025 17:55:31 +0100 Subject: [PATCH 1/2] PoC(tableau): codegen PoC --- metadata-ingestion/setup.py | 2 +- .../tableau/codegen_ariadne/__init__.py | 0 .../codegen_ariadne/async_base_client.py | 372 + .../tableau/codegen_ariadne/base_model.py | 29 + .../source/tableau/codegen_ariadne/client.py | 583 + .../source/tableau/codegen_ariadne/enums.py | 634 + .../tableau/codegen_ariadne/exceptions.py | 85 + .../get_items_custom_sql_tables_connection.py | 269 + .../get_items_database_tables_connection.py | 45 + ...t_items_embedded_datasources_connection.py | 211 + .../get_items_fields_connection.py | 93 + ..._items_published_datasources_connection.py | 193 + .../get_items_sheets_connection.py | 291 + .../get_items_workbooks_connection.py | 70 + .../tableau/codegen_ariadne/input_types.py | 1437 + .../source/tableau/codegen_sgqlc/__init__.py | 0 .../codegen_sgqlc/tableau_operations.py | 584 + .../tableau/codegen_sgqlc/tableau_schema.py | 54071 ++++++++++++++++ .../source/tableau/codegen_turms/__init__.py | 0 .../source/tableau/codegen_turms/schema.py | 1893 + .../ingestion/source/tableau/tableau.py | 234 + 21 files changed, 61095 insertions(+), 1 deletion(-) create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/__init__.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/async_base_client.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/base_model.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/client.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/enums.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/exceptions.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_database_tables_connection.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_embedded_datasources_connection.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_fields_connection.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_published_datasources_connection.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/input_types.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/__init__.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_operations.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/__init__.py create mode 100644 metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/schema.py diff --git a/metadata-ingestion/setup.py b/metadata-ingestion/setup.py index b317598930984..a9f5dffa88eac 100644 --- a/metadata-ingestion/setup.py +++ b/metadata-ingestion/setup.py @@ -495,7 +495,7 @@ "slack": slack, "superset": superset_common, "preset": superset_common, - "tableau": {"tableauserverclient>=0.24.0"} | sqlglot_lib, + "tableau": {"tableauserverclient>=0.24.0"} | sqlglot_lib | {"sgqlc"}, "teradata": sql_common | usage_common | sqlglot_lib diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/__init__.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/__init__.py new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/async_base_client.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/async_base_client.py new file mode 100644 index 0000000000000..889ae1f933cba --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/async_base_client.py @@ -0,0 +1,372 @@ +# Generated by ariadne-codegen + +import enum +import json +from typing import IO, Any, AsyncIterator, Dict, List, Optional, Tuple, TypeVar, cast +from uuid import uuid4 + +import httpx +from pydantic import BaseModel +from pydantic_core import to_jsonable_python + +from datahub.ingestion.source.tableau.codegen_ariadne.base_model import UNSET, Upload +from datahub.ingestion.source.tableau.codegen_ariadne.exceptions import ( + GraphQLClientGraphQLMultiError, + GraphQLClientHttpError, + GraphQLClientInvalidMessageFormat, + GraphQLClientInvalidResponseError, +) + +try: + from websockets.client import ( # type: ignore[import-not-found,unused-ignore] + WebSocketClientProtocol, + connect as ws_connect, + ) + from websockets.typing import ( # type: ignore[import-not-found,unused-ignore] + Data, + Origin, + Subprotocol, + ) +except ImportError: + from contextlib import asynccontextmanager + + @asynccontextmanager # type: ignore + async def ws_connect(*args, **kwargs): # pylint: disable=unused-argument + raise NotImplementedError("Subscriptions require 'websockets' package.") + yield # pylint: disable=unreachable + + WebSocketClientProtocol = Any # type: ignore[misc,assignment,unused-ignore] + Data = Any # type: ignore[misc,assignment,unused-ignore] + Origin = Any # type: ignore[misc,assignment,unused-ignore] + + def Subprotocol(*args, **kwargs): # type: ignore # pylint: disable=invalid-name + raise NotImplementedError("Subscriptions require 'websockets' package.") + + +Self = TypeVar("Self", bound="AsyncBaseClient") + +GRAPHQL_TRANSPORT_WS = "graphql-transport-ws" + + +class GraphQLTransportWSMessageType(str, enum.Enum): + CONNECTION_INIT = "connection_init" + CONNECTION_ACK = "connection_ack" + PING = "ping" + PONG = "pong" + SUBSCRIBE = "subscribe" + NEXT = "next" + ERROR = "error" + COMPLETE = "complete" + + +class AsyncBaseClient: + def __init__( + self, + url: str = "", + headers: Optional[Dict[str, str]] = None, + http_client: Optional[httpx.AsyncClient] = None, + ws_url: str = "", + ws_headers: Optional[Dict[str, Any]] = None, + ws_origin: Optional[str] = None, + ws_connection_init_payload: Optional[Dict[str, Any]] = None, + ) -> None: + self.url = url + self.headers = headers + self.http_client = ( + http_client if http_client else httpx.AsyncClient(headers=headers) + ) + + self.ws_url = ws_url + self.ws_headers = ws_headers or {} + self.ws_origin = Origin(ws_origin) if ws_origin else None + self.ws_connection_init_payload = ws_connection_init_payload + + async def __aenter__(self: Self) -> Self: + return self + + async def __aexit__( + self, + exc_type: object, + exc_val: object, + exc_tb: object, + ) -> None: + await self.http_client.aclose() + + async def execute( + self, + query: str, + operation_name: Optional[str] = None, + variables: Optional[Dict[str, Any]] = None, + **kwargs: Any, + ) -> httpx.Response: + processed_variables, files, files_map = self._process_variables(variables) + + if files and files_map: + return await self._execute_multipart( + query=query, + operation_name=operation_name, + variables=processed_variables, + files=files, + files_map=files_map, + **kwargs, + ) + + return await self._execute_json( + query=query, + operation_name=operation_name, + variables=processed_variables, + **kwargs, + ) + + def get_data(self, response: httpx.Response) -> Dict[str, Any]: + if not response.is_success: + raise GraphQLClientHttpError( + status_code=response.status_code, response=response + ) + + try: + response_json = response.json() + except ValueError as exc: + raise GraphQLClientInvalidResponseError(response=response) from exc + + if (not isinstance(response_json, dict)) or ( + "data" not in response_json and "errors" not in response_json + ): + raise GraphQLClientInvalidResponseError(response=response) + + data = response_json.get("data") + errors = response_json.get("errors") + + if errors: + raise GraphQLClientGraphQLMultiError.from_errors_dicts( + errors_dicts=errors, data=data + ) + + return cast(Dict[str, Any], data) + + async def execute_ws( + self, + query: str, + operation_name: Optional[str] = None, + variables: Optional[Dict[str, Any]] = None, + **kwargs: Any, + ) -> AsyncIterator[Dict[str, Any]]: + headers = self.ws_headers.copy() + headers.update(kwargs.get("extra_headers", {})) + + merged_kwargs: Dict[str, Any] = {"origin": self.ws_origin} + merged_kwargs.update(kwargs) + merged_kwargs["extra_headers"] = headers + + operation_id = str(uuid4()) + async with ws_connect( + self.ws_url, + subprotocols=[Subprotocol(GRAPHQL_TRANSPORT_WS)], + **merged_kwargs, + ) as websocket: + await self._send_connection_init(websocket) + # wait for connection_ack from server + await self._handle_ws_message( + await websocket.recv(), + websocket, + expected_type=GraphQLTransportWSMessageType.CONNECTION_ACK, + ) + await self._send_subscribe( + websocket, + operation_id=operation_id, + query=query, + operation_name=operation_name, + variables=variables, + ) + + async for message in websocket: + data = await self._handle_ws_message(message, websocket) + if data: + yield data + + def _process_variables( + self, variables: Optional[Dict[str, Any]] + ) -> Tuple[ + Dict[str, Any], Dict[str, Tuple[str, IO[bytes], str]], Dict[str, List[str]] + ]: + if not variables: + return {}, {}, {} + + serializable_variables = self._convert_dict_to_json_serializable(variables) + return self._get_files_from_variables(serializable_variables) + + def _convert_dict_to_json_serializable( + self, dict_: Dict[str, Any] + ) -> Dict[str, Any]: + return { + key: self._convert_value(value) + for key, value in dict_.items() + if value is not UNSET + } + + def _convert_value(self, value: Any) -> Any: + if isinstance(value, BaseModel): + return value.model_dump(by_alias=True, exclude_unset=True) + if isinstance(value, list): + return [self._convert_value(item) for item in value] + return value + + def _get_files_from_variables( + self, variables: Dict[str, Any] + ) -> Tuple[ + Dict[str, Any], Dict[str, Tuple[str, IO[bytes], str]], Dict[str, List[str]] + ]: + files_map: Dict[str, List[str]] = {} + files_list: List[Upload] = [] + + def separate_files(path: str, obj: Any) -> Any: + if isinstance(obj, list): + nulled_list = [] + for index, value in enumerate(obj): + value = separate_files(f"{path}.{index}", value) + nulled_list.append(value) + return nulled_list + + if isinstance(obj, dict): + nulled_dict = {} + for key, value in obj.items(): + value = separate_files(f"{path}.{key}", value) + nulled_dict[key] = value + return nulled_dict + + if isinstance(obj, Upload): + if obj in files_list: + file_index = files_list.index(obj) + files_map[str(file_index)].append(path) + else: + file_index = len(files_list) + files_list.append(obj) + files_map[str(file_index)] = [path] + return None + + return obj + + nulled_variables = separate_files("variables", variables) + files: Dict[str, Tuple[str, IO[bytes], str]] = { + str(i): (file_.filename, cast(IO[bytes], file_.content), file_.content_type) + for i, file_ in enumerate(files_list) + } + return nulled_variables, files, files_map + + async def _execute_multipart( + self, + query: str, + operation_name: Optional[str], + variables: Dict[str, Any], + files: Dict[str, Tuple[str, IO[bytes], str]], + files_map: Dict[str, List[str]], + **kwargs: Any, + ) -> httpx.Response: + data = { + "operations": json.dumps( + { + "query": query, + "operationName": operation_name, + "variables": variables, + }, + default=to_jsonable_python, + ), + "map": json.dumps(files_map, default=to_jsonable_python), + } + + return await self.http_client.post( + url=self.url, data=data, files=files, **kwargs + ) + + async def _execute_json( + self, + query: str, + operation_name: Optional[str], + variables: Dict[str, Any], + **kwargs: Any, + ) -> httpx.Response: + headers: Dict[str, str] = {"Content-Type": "application/json"} + headers.update(kwargs.get("headers", {})) + + merged_kwargs: Dict[str, Any] = kwargs.copy() + merged_kwargs["headers"] = headers + + return await self.http_client.post( + url=self.url, + content=json.dumps( + { + "query": query, + "operationName": operation_name, + "variables": variables, + }, + default=to_jsonable_python, + ), + **merged_kwargs, + ) + + async def _send_connection_init(self, websocket: WebSocketClientProtocol) -> None: + payload: Dict[str, Any] = { + "type": GraphQLTransportWSMessageType.CONNECTION_INIT.value + } + if self.ws_connection_init_payload: + payload["payload"] = self.ws_connection_init_payload + await websocket.send(json.dumps(payload)) + + async def _send_subscribe( + self, + websocket: WebSocketClientProtocol, + operation_id: str, + query: str, + operation_name: Optional[str] = None, + variables: Optional[Dict[str, Any]] = None, + ) -> None: + payload: Dict[str, Any] = { + "id": operation_id, + "type": GraphQLTransportWSMessageType.SUBSCRIBE.value, + "payload": {"query": query, "operationName": operation_name}, + } + if variables: + payload["payload"]["variables"] = self._convert_dict_to_json_serializable( + variables + ) + await websocket.send(json.dumps(payload)) + + async def _handle_ws_message( + self, + message: Data, + websocket: WebSocketClientProtocol, + expected_type: Optional[GraphQLTransportWSMessageType] = None, + ) -> Optional[Dict[str, Any]]: + try: + message_dict = json.loads(message) + except json.JSONDecodeError as exc: + raise GraphQLClientInvalidMessageFormat(message=message) from exc + + type_ = message_dict.get("type") + payload = message_dict.get("payload", {}) + + if not type_ or type_ not in {t.value for t in GraphQLTransportWSMessageType}: + raise GraphQLClientInvalidMessageFormat(message=message) + + if expected_type and expected_type != type_: + raise GraphQLClientInvalidMessageFormat( + f"Invalid message received. Expected: {expected_type.value}" + ) + + if type_ == GraphQLTransportWSMessageType.NEXT: + if "data" not in payload: + raise GraphQLClientInvalidMessageFormat(message=message) + return cast(Dict[str, Any], payload["data"]) + + if type_ == GraphQLTransportWSMessageType.COMPLETE: + await websocket.close() + elif type_ == GraphQLTransportWSMessageType.PING: + await websocket.send( + json.dumps({"type": GraphQLTransportWSMessageType.PONG.value}) + ) + elif type_ == GraphQLTransportWSMessageType.ERROR: + raise GraphQLClientGraphQLMultiError.from_errors_dicts( + errors_dicts=payload, data=message_dict + ) + + return None diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/base_model.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/base_model.py new file mode 100644 index 0000000000000..76b84873a6f11 --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/base_model.py @@ -0,0 +1,29 @@ +# Generated by ariadne-codegen + +from io import IOBase + +from pydantic import BaseModel as PydanticBaseModel, ConfigDict + + +class UnsetType: + def __bool__(self) -> bool: + return False + + +UNSET = UnsetType() + + +class BaseModel(PydanticBaseModel): + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + arbitrary_types_allowed=True, + protected_namespaces=(), + ) + + +class Upload: + def __init__(self, filename: str, content: IOBase, content_type: str): + self.filename = filename + self.content = content + self.content_type = content_type diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/client.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/client.py new file mode 100644 index 0000000000000..fd17d6ae847ca --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/client.py @@ -0,0 +1,583 @@ +# Generated by ariadne-codegen +# Source: ./tableau-queries.graphql + +from typing import Any, Dict, Optional, Union + +from datahub.ingestion.source.tableau.codegen_ariadne.async_base_client import ( + AsyncBaseClient, +) +from datahub.ingestion.source.tableau.codegen_ariadne.base_model import UNSET, UnsetType +from datahub.ingestion.source.tableau.codegen_ariadne.get_items_custom_sql_tables_connection import ( + GetItemsCustomSQLTablesConnection, +) +from datahub.ingestion.source.tableau.codegen_ariadne.get_items_database_tables_connection import ( + GetItemsDatabaseTablesConnection, +) +from datahub.ingestion.source.tableau.codegen_ariadne.get_items_embedded_datasources_connection import ( + GetItemsEmbeddedDatasourcesConnection, +) +from datahub.ingestion.source.tableau.codegen_ariadne.get_items_fields_connection import ( + GetItemsFieldsConnection, +) +from datahub.ingestion.source.tableau.codegen_ariadne.get_items_published_datasources_connection import ( + GetItemsPublishedDatasourcesConnection, +) +from datahub.ingestion.source.tableau.codegen_ariadne.get_items_sheets_connection import ( + GetItemsSheetsConnection, +) +from datahub.ingestion.source.tableau.codegen_ariadne.get_items_workbooks_connection import ( + GetItemsWorkbooksConnection, +) + + +def gql(q: str) -> str: + return q + + +class Client(AsyncBaseClient): + async def get_items_database_tables_connection( + self, + first: Union[Optional[int], UnsetType] = UNSET, + after: Union[Optional[str], UnsetType] = UNSET, + **kwargs: Any, + ) -> GetItemsDatabaseTablesConnection: + query = gql( + """ + query GetItems_databaseTablesConnection($first: Int, $after: String) { + databaseTablesConnection( + first: $first + after: $after + filter: {idWithin: ["76e2151b-124f-7ec8-896b-dd107eafca05", "a1b165ad-c7c2-282d-94c5-1b8a877936ee", "2d3bdb4e-08da-a6da-fecb-a3c10abba357", "92b0a3ae-2fc9-1b42-47e0-c17d0f0b615a", "63ffbbfe-8c2d-c4f3-7a28-e11f247227c7", "06d776e1-9376-bc06-84d5-c7a5c4253bf5", "159ed86e-796f-3f13-8f07-3e63c271015e", "2f2ccb48-edd5-0e02-4d51-eb3b0819fbf1", "2fe499f7-9c5a-81ef-f32d-9553dcc86044", "4a34ada9-ed4a-089f-01d0-4a1f230ee2e6"]} + ) { + nodes { + id + isEmbedded + columns { + remoteType + name + } + } + pageInfo { + hasNextPage + endCursor + } + } + } + """ + ) + variables: Dict[str, object] = {"first": first, "after": after} + response = await self.execute( + query=query, + operation_name="GetItems_databaseTablesConnection", + variables=variables, + **kwargs, + ) + data = self.get_data(response) + return GetItemsDatabaseTablesConnection.model_validate(data) + + async def get_items_custom_sql_tables_connection( + self, + first: Union[Optional[int], UnsetType] = UNSET, + after: Union[Optional[str], UnsetType] = UNSET, + **kwargs: Any, + ) -> GetItemsCustomSQLTablesConnection: + query = gql( + """ + query GetItems_customSQLTablesConnection($first: Int, $after: String) { + customSQLTablesConnection( + first: $first + after: $after + filter: {idWithin: ["81335c49-5edc-bbfa-77c9-c4a1cd444501", "48c19c5f-4300-07bb-17ee-1fbdf6824ff6"]} + ) { + nodes { + id + name + query + columns { + id + name + remoteType + description + referencedByFields { + datasource { + __typename + id + name + upstreamTables { + id + name + database { + __typename + name + id + } + schema + fullName + connectionType + } + ... on PublishedDatasource { + projectName + luid + } + ... on EmbeddedDatasource { + workbook { + id + name + projectName + luid + } + } + } + } + } + tables { + id + name + database { + __typename + name + id + } + schema + fullName + connectionType + description + columnsConnection { + totalCount + } + } + connectionType + database { + __typename + name + id + connectionType + } + } + pageInfo { + hasNextPage + endCursor + } + } + } + """ + ) + variables: Dict[str, object] = {"first": first, "after": after} + response = await self.execute( + query=query, + operation_name="GetItems_customSQLTablesConnection", + variables=variables, + **kwargs, + ) + data = self.get_data(response) + return GetItemsCustomSQLTablesConnection.model_validate(data) + + async def get_items_published_datasources_connection( + self, + first: Union[Optional[int], UnsetType] = UNSET, + after: Union[Optional[str], UnsetType] = UNSET, + **kwargs: Any, + ) -> GetItemsPublishedDatasourcesConnection: + query = gql( + """ + query GetItems_publishedDatasourcesConnection($first: Int, $after: String) { + publishedDatasourcesConnection( + first: $first + after: $after + filter: {idWithin: ["35d62018-68e1-6ad4-2cf0-d3ede4ee9a67", "87d9d9d8-59a8-adc3-3e06-f75c5b98ec52", "ae8b52c9-1481-06fd-fe96-e6d4938f9fcb"]} + ) { + nodes { + __typename + id + name + luid + hasExtracts + extractLastRefreshTime + extractLastIncrementalUpdateTime + extractLastUpdateTime + upstreamTables { + id + name + database { + __typename + name + id + } + schema + fullName + connectionType + description + columnsConnection { + totalCount + } + } + fields { + __typename + id + name + description + isHidden + folderName + ... on ColumnField { + dataCategory + role + dataType + defaultFormat + aggregation + } + ... on CalculatedField { + role + dataType + defaultFormat + aggregation + formula + } + ... on GroupField { + role + dataType + } + } + owner { + username + } + description + uri + projectName + tags { + name + } + } + pageInfo { + hasNextPage + endCursor + } + } + } + """ + ) + variables: Dict[str, object] = {"first": first, "after": after} + response = await self.execute( + query=query, + operation_name="GetItems_publishedDatasourcesConnection", + variables=variables, + **kwargs, + ) + data = self.get_data(response) + return GetItemsPublishedDatasourcesConnection.model_validate(data) + + async def get_items_fields_connection( + self, + first: Union[Optional[int], UnsetType] = UNSET, + after: Union[Optional[str], UnsetType] = UNSET, + **kwargs: Any, + ) -> GetItemsFieldsConnection: + query = gql( + """ + query GetItems_fieldsConnection($first: Int, $after: String) { + fieldsConnection( + first: $first + after: $after + filter: {idWithin: ["668470bc-f0c9-ec5d-7a4b-172370d6ef45", "66bd48ba-a895-4951-a4e1-d26fc191eae9", "672a63ee-c34b-8cb4-506b-163fcb131a52", "72684adf-d214-0a9a-946c-dd7b3879b51f", "76636a30-dfbf-0107-0190-a0fc6ce201be", "77aa21d6-3b79-0be0-d309-3d36ef1efe71", "8fbf178a-ceef-2c97-3ac8-26f95a004d67", "968608d1-5da4-1a97-e96a-269010d4ef5b", "b5ae252a-c3c0-3a2d-c147-7a39a8de59ef", "bc1641b9-525d-00c5-f163-02519d46f0fd"]} + ) { + nodes { + __typename + id + upstreamFields { + __typename + name + datasource { + __typename + id + } + } + upstreamColumns { + name + table { + __typename + id + } + } + } + pageInfo { + hasNextPage + endCursor + } + } + } + """ + ) + variables: Dict[str, object] = {"first": first, "after": after} + response = await self.execute( + query=query, + operation_name="GetItems_fieldsConnection", + variables=variables, + **kwargs, + ) + data = self.get_data(response) + return GetItemsFieldsConnection.model_validate(data) + + async def get_items_embedded_datasources_connection( + self, + first: Union[Optional[int], UnsetType] = UNSET, + after: Union[Optional[str], UnsetType] = UNSET, + **kwargs: Any, + ) -> GetItemsEmbeddedDatasourcesConnection: + query = gql( + """ + query GetItems_embeddedDatasourcesConnection($first: Int, $after: String) { + embeddedDatasourcesConnection( + first: $first + after: $after + filter: {idWithin: ["7437c561-4e94-0283-3462-c6205c2288cd", "797a69b1-c32a-2fd4-62aa-99989c1858a6", "79871b17-d526-17be-df59-e001f7140924", "8f5e3006-6756-8eea-4fd3-44781cea1493", "1c5653d6-c448-0850-108b-5c78aeaf6b51", "6731f648-b756-31ea-fcdd-77309dd3b0c3", "6bd53e72-9fe4-ea86-3d23-14b826c13fa5", "3f46592d-f789-8f48-466e-69606990d589", "415ddd3e-be04-b466-bc7c-5678a4b0a733", "e9b47a00-12ff-72cc-9dfb-d34e0c65095d"]} + ) { + nodes { + __typename + id + name + hasExtracts + extractLastRefreshTime + extractLastIncrementalUpdateTime + extractLastUpdateTime + downstreamSheets { + name + id + } + upstreamTables { + id + name + database { + __typename + name + id + } + schema + fullName + connectionType + description + columnsConnection { + totalCount + } + } + fields { + __typename + id + name + description + isHidden + folderName + ... on ColumnField { + dataCategory + role + dataType + defaultFormat + aggregation + } + ... on CalculatedField { + role + dataType + defaultFormat + aggregation + formula + } + ... on GroupField { + role + dataType + } + } + upstreamDatasources { + id + name + } + workbook { + id + name + projectName + luid + owner { + username + } + } + } + pageInfo { + hasNextPage + endCursor + } + } + } + """ + ) + variables: Dict[str, object] = {"first": first, "after": after} + response = await self.execute( + query=query, + operation_name="GetItems_embeddedDatasourcesConnection", + variables=variables, + **kwargs, + ) + data = self.get_data(response) + return GetItemsEmbeddedDatasourcesConnection.model_validate(data) + + async def get_items_sheets_connection( + self, + first: Union[Optional[int], UnsetType] = UNSET, + after: Union[Optional[str], UnsetType] = UNSET, + **kwargs: Any, + ) -> GetItemsSheetsConnection: + query = gql( + """ + query GetItems_sheetsConnection($first: Int, $after: String) { + sheetsConnection( + first: $first + after: $after + filter: {idWithin: ["fa9e30e8-645e-1105-642d-c292c70a921c", "cea027c2-24a2-d009-4ccf-ac172a3fac6e", "b4f94b9f-26dc-3fb3-1973-796e4c91cb21", "f6682a87-7396-f12e-2fd1-0424157c6ceb", "8fb398c1-0b18-528a-c3bd-2a03c35528f5", "ffe3435f-3e0b-9618-389c-055cbed13ac9", "4e51108f-3ba4-0749-6518-8104fc62c202", "67f86c94-c102-447a-8752-b1e497bf4551", "cbb0b196-5f2a-ecd4-0b2b-e87db220ff47", "1359177d-c634-2cff-4408-1751152c7fc2"]} + ) { + nodes { + id + name + path + luid + createdAt + updatedAt + tags { + name + } + containedInDashboards { + name + path + } + workbook { + id + name + projectName + luid + owner { + username + } + } + datasourceFields { + __typename + id + name + description + datasource { + __typename + id + name + } + ... on ColumnField { + dataCategory + role + dataType + aggregation + } + ... on CalculatedField { + role + dataType + aggregation + formula + } + ... on GroupField { + role + dataType + } + ... on DatasourceField { + remoteField { + __typename + id + name + description + folderName + ... on ColumnField { + dataCategory + role + dataType + aggregation + } + ... on CalculatedField { + role + dataType + aggregation + formula + } + ... on GroupField { + role + dataType + } + } + } + } + } + pageInfo { + hasNextPage + endCursor + } + } + } + """ + ) + variables: Dict[str, object] = {"first": first, "after": after} + response = await self.execute( + query=query, + operation_name="GetItems_sheetsConnection", + variables=variables, + **kwargs, + ) + data = self.get_data(response) + return GetItemsSheetsConnection.model_validate(data) + + async def get_items_workbooks_connection( + self, + first: Union[Optional[int], UnsetType] = UNSET, + after: Union[Optional[str], UnsetType] = UNSET, + **kwargs: Any, + ) -> GetItemsWorkbooksConnection: + query = gql( + """ + query GetItems_workbooksConnection($first: Int, $after: String) { + workbooksConnection( + first: $first + after: $after + filter: {projectNameWithin: ["project_test2"]} + ) { + nodes { + id + name + luid + uri + projectName + owner { + username + } + description + uri + createdAt + updatedAt + tags { + name + } + sheets { + id + } + dashboards { + id + } + embeddedDatasources { + id + } + } + pageInfo { + hasNextPage + endCursor + } + } + } + """ + ) + variables: Dict[str, object] = {"first": first, "after": after} + response = await self.execute( + query=query, + operation_name="GetItems_workbooksConnection", + variables=variables, + **kwargs, + ) + data = self.get_data(response) + return GetItemsWorkbooksConnection.model_validate(data) diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/enums.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/enums.py new file mode 100644 index 0000000000000..08b1be5d7e507 --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/enums.py @@ -0,0 +1,634 @@ +# Generated by ariadne-codegen +# Source: ../../schemas/tableau/schema.graphql + +from enum import Enum + + +class AnalyticsFieldOrderField(str, Enum): + ID = "ID" + + +class AskDataExtensionOrderField(str, Enum): + ID = "ID" + + +class BinFieldOrderField(str, Enum): + DATA_CATEGORY = "DATA_CATEGORY" + DATA_TYPE = "DATA_TYPE" + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + IS_HIDDEN = "IS_HIDDEN" + NAME = "NAME" + ROLE = "ROLE" + + +class CalculatedFieldOrderField(str, Enum): + DATA_CATEGORY = "DATA_CATEGORY" + DATA_TYPE = "DATA_TYPE" + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + IS_HIDDEN = "IS_HIDDEN" + NAME = "NAME" + ROLE = "ROLE" + + +class CanHaveLabelsOrderField(str, Enum): + ID = "ID" + LUID = "LUID" + + +class CertifiableOrderField(str, Enum): + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + LUID = "LUID" + + +class CloudFileOrderField(str, Enum): + CONNECTION_TYPE = "CONNECTION_TYPE" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT = "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + IS_EMBEDDED = "IS_EMBEDDED" + LUID = "LUID" + NAME = "NAME" + PROJECT_NAME = "PROJECT_NAME" + + +class ColumnFieldOrderField(str, Enum): + DATA_CATEGORY = "DATA_CATEGORY" + DATA_TYPE = "DATA_TYPE" + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + ID = "ID" + IS_HIDDEN = "IS_HIDDEN" + NAME = "NAME" + ROLE = "ROLE" + + +class ColumnOrderField(str, Enum): + DISPLAY_NAME = "DISPLAY_NAME" + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + LUID = "LUID" + NAME = "NAME" + + +class CombinedFieldOrderField(str, Enum): + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + IS_HIDDEN = "IS_HIDDEN" + NAME = "NAME" + + +class CombinedSetFieldOrderField(str, Enum): + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + IS_HIDDEN = "IS_HIDDEN" + NAME = "NAME" + + +class CustomSQLTableOrderField(str, Enum): + COLUMNS_COUNT = "COLUMNS_COUNT" + DOWNSTREAM_DASHBOARDS_COUNT = "DOWNSTREAM_DASHBOARDS_COUNT" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + ID = "ID" + IS_UNSUPPORTED_CUSTOM_SQL = "IS_UNSUPPORTED_CUSTOM_SQL" + NAME = "NAME" + + +class DashboardOrderField(str, Enum): + DOCUMENT_VIEW_ID = "DOCUMENT_VIEW_ID" + ID = "ID" + LUID = "LUID" + NAME = "NAME" + PATH = "PATH" + + +class DataCloudOrderField(str, Enum): + CONNECTION_TYPE = "CONNECTION_TYPE" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT = "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + IS_EMBEDDED = "IS_EMBEDDED" + LUID = "LUID" + NAME = "NAME" + PROJECT_NAME = "PROJECT_NAME" + + +class DataFieldOrderField(str, Enum): + DATA_CATEGORY = "DATA_CATEGORY" + DATA_TYPE = "DATA_TYPE" + ID = "ID" + ROLE = "ROLE" + + +class DataQualityCertificationOrderField(str, Enum): + CATEGORY = "CATEGORY" + ID = "ID" + IS_ACTIVE = "IS_ACTIVE" + IS_ELEVATED = "IS_ELEVATED" + LUID = "LUID" + VALUE = "VALUE" + + +class DataQualityWarningOrderField(str, Enum): + CATEGORY = "CATEGORY" + ID = "ID" + IS_ACTIVE = "IS_ACTIVE" + IS_ELEVATED = "IS_ELEVATED" + IS_SEVERE = "IS_SEVERE" + LUID = "LUID" + VALUE = "VALUE" + WARNING_TYPE = "WARNING_TYPE" + + +class DatabaseOrderField(str, Enum): + CONNECTION_TYPE = "CONNECTION_TYPE" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT = "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + IS_EMBEDDED = "IS_EMBEDDED" + LUID = "LUID" + NAME = "NAME" + PROJECT_NAME = "PROJECT_NAME" + + +class DatabaseServerOrderField(str, Enum): + CONNECTION_TYPE = "CONNECTION_TYPE" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT = "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + HOST_NAME = "HOST_NAME" + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + IS_EMBEDDED = "IS_EMBEDDED" + LUID = "LUID" + NAME = "NAME" + PROJECT_NAME = "PROJECT_NAME" + + +class DatabaseTableOrderField(str, Enum): + COLUMNS_COUNT = "COLUMNS_COUNT" + CONNECTION_TYPE = "CONNECTION_TYPE" + DOWNSTREAM_DASHBOARDS_COUNT = "DOWNSTREAM_DASHBOARDS_COUNT" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT = "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + FULL_NAME = "FULL_NAME" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + IS_EMBEDDED = "IS_EMBEDDED" + LUID = "LUID" + NAME = "NAME" + PROJECT_NAME = "PROJECT_NAME" + SCHEMA = "SCHEMA" + + +class DatasourceFieldOrderField(str, Enum): + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + ID = "ID" + IS_HIDDEN = "IS_HIDDEN" + NAME = "NAME" + + +class DatasourceFilterOrderField(str, Enum): + ID = "ID" + + +class DatasourceOrderField(str, Enum): + CONTAINS_UNSUPPORTED_CUSTOM_SQL = "CONTAINS_UNSUPPORTED_CUSTOM_SQL" + DOWNSTREAM_OWNERS_COUNT = "DOWNSTREAM_OWNERS_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + NAME = "NAME" + + +class EmbeddedDatasourceOrderField(str, Enum): + CONTAINS_UNSUPPORTED_CUSTOM_SQL = "CONTAINS_UNSUPPORTED_CUSTOM_SQL" + DOWNSTREAM_OWNERS_COUNT = "DOWNSTREAM_OWNERS_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + NAME = "NAME" + + +class ExtractType(str, Enum): + FULL = "FULL" + INCREMENTAL = "INCREMENTAL" + + +class FieldDataType(str, Enum): + BOOLEAN = "BOOLEAN" + DATE = "DATE" + DATETIME = "DATETIME" + INTEGER = "INTEGER" + REAL = "REAL" + SPATIAL = "SPATIAL" + STRING = "STRING" + TABLE = "TABLE" + TUPLE = "TUPLE" + UNKNOWN = "UNKNOWN" + + +class FieldOrderField(str, Enum): + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + ID = "ID" + IS_HIDDEN = "IS_HIDDEN" + NAME = "NAME" + + +class FieldReferencingFieldOrderField(str, Enum): + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + + +class FieldRole(str, Enum): + DIMENSION = "DIMENSION" + MEASURE = "MEASURE" + UNKNOWN = "UNKNOWN" + + +class FieldRoleCategory(str, Enum): + NOMINAL = "NOMINAL" + ORDINAL = "ORDINAL" + QUANTITATIVE = "QUANTITATIVE" + UNKNOWN = "UNKNOWN" + + +class FileOrderField(str, Enum): + CONNECTION_TYPE = "CONNECTION_TYPE" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT = "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + IS_EMBEDDED = "IS_EMBEDDED" + LUID = "LUID" + NAME = "NAME" + PROJECT_NAME = "PROJECT_NAME" + + +class FlowColumnInputFieldOrderField(str, Enum): + ID = "ID" + NAME = "NAME" + + +class FlowColumnOutputFieldOrderField(str, Enum): + ID = "ID" + NAME = "NAME" + + +class FlowFieldInputFieldOrderField(str, Enum): + ID = "ID" + NAME = "NAME" + + +class FlowFieldOutputFieldOrderField(str, Enum): + ID = "ID" + NAME = "NAME" + + +class FlowInputFieldOrderField(str, Enum): + ID = "ID" + NAME = "NAME" + + +class FlowOrderField(str, Enum): + CONTAINER_NAME = "CONTAINER_NAME" + CONTAINS_UNSUPPORTED_CUSTOM_SQL = "CONTAINS_UNSUPPORTED_CUSTOM_SQL" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + LUID = "LUID" + NAME = "NAME" + PROJECT_NAME = "PROJECT_NAME" + VIZPORTAL_URL_ID = "VIZPORTAL_URL_ID" + + +class FlowOutputFieldOrderField(str, Enum): + ID = "ID" + NAME = "NAME" + + +class FlowOutputStepOrderField(str, Enum): + ID = "ID" + NAME = "NAME" + + +class GenericLabelOrderField(str, Enum): + CATEGORY = "CATEGORY" + ID = "ID" + IS_ACTIVE = "IS_ACTIVE" + IS_ELEVATED = "IS_ELEVATED" + LUID = "LUID" + VALUE = "VALUE" + + +class GroupFieldOrderField(str, Enum): + DATA_CATEGORY = "DATA_CATEGORY" + DATA_TYPE = "DATA_TYPE" + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + IS_HIDDEN = "IS_HIDDEN" + NAME = "NAME" + ROLE = "ROLE" + + +class HierarchyFieldOrderField(str, Enum): + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + IS_HIDDEN = "IS_HIDDEN" + NAME = "NAME" + + +class InheritanceType(str, Enum): + FIRST = "FIRST" + + +class LabelOrderField(str, Enum): + CATEGORY = "CATEGORY" + ID = "ID" + IS_ACTIVE = "IS_ACTIVE" + IS_ELEVATED = "IS_ELEVATED" + LUID = "LUID" + VALUE = "VALUE" + + +class LensFieldOrderField(str, Enum): + ID = "ID" + NAME = "NAME" + + +class LensOrderField(str, Enum): + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + LUID = "LUID" + NAME = "NAME" + OWNER_COUNT = "OWNER_COUNT" + VIZPORTAL_URL_ID = "VIZPORTAL_URL_ID" + + +class LinkedFlowOrderField(str, Enum): + ID = "ID" + + +class MetricDefinitionOrderField(str, Enum): + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + LUID = "LUID" + NAME = "NAME" + + +class MetricOrderField(str, Enum): + CONTAINER_NAME = "CONTAINER_NAME" + ID = "ID" + LUID = "LUID" + NAME = "NAME" + OWNER_COUNT = "OWNER_COUNT" + PROJECT_NAME = "PROJECT_NAME" + VIZPORTAL_URL_ID = "VIZPORTAL_URL_ID" + + +class NodeOrderField(str, Enum): + ID = "ID" + + +class OrderDirection(str, Enum): + ASC = "ASC" + DESC = "DESC" + + +class ParameterOrderField(str, Enum): + ID = "ID" + NAME = "NAME" + PARENT_NAME = "PARENT_NAME" + + +class PermissionMode(str, Enum): + FILTER_RESULTS = "FILTER_RESULTS" + OBFUSCATE_RESULTS = "OBFUSCATE_RESULTS" + + +class PublishedDatasourceOrderField(str, Enum): + CONTAINER_NAME = "CONTAINER_NAME" + CONTAINS_UNSUPPORTED_CUSTOM_SQL = "CONTAINS_UNSUPPORTED_CUSTOM_SQL" + DOWNSTREAM_OWNERS_COUNT = "DOWNSTREAM_OWNERS_COUNT" + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + FIELDS_COUNT = "FIELDS_COUNT" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + LUID = "LUID" + NAME = "NAME" + OWNER_COUNT = "OWNER_COUNT" + PROJECT_NAME = "PROJECT_NAME" + VIZPORTAL_URL_ID = "VIZPORTAL_URL_ID" + + +class RemoteType(str, Enum): + ARRAY = "ARRAY" + BOOL = "BOOL" + BSTR = "BSTR" + BYREF = "BYREF" + BYTES = "BYTES" + CY = "CY" + DATE = "DATE" + DBDATE = "DBDATE" + DBTIME = "DBTIME" + DBTIMESTAMP = "DBTIMESTAMP" + DECIMAL = "DECIMAL" + EMPTY = "EMPTY" + ERROR = "ERROR" + FILETIME = "FILETIME" + GUID = "GUID" + HCHAPTER = "HCHAPTER" + I1 = "I1" + I2 = "I2" + I4 = "I4" + I8 = "I8" + IDISPATCH = "IDISPATCH" + IUNKNOWN = "IUNKNOWN" + NULL = "NULL" + NUMERIC = "NUMERIC" + PROPVARIANT = "PROPVARIANT" + R4 = "R4" + R8 = "R8" + RESERVED = "RESERVED" + STR = "STR" + UDT = "UDT" + UI1 = "UI1" + UI2 = "UI2" + UI4 = "UI4" + UI8 = "UI8" + VARIANT = "VARIANT" + VARNUMERIC = "VARNUMERIC" + VECTOR = "VECTOR" + WDC_BOOL = "WDC_BOOL" + WDC_DATE = "WDC_DATE" + WDC_DATETIME = "WDC_DATETIME" + WDC_FLOAT = "WDC_FLOAT" + WDC_GEOMETRY = "WDC_GEOMETRY" + WDC_INT = "WDC_INT" + WDC_STRING = "WDC_STRING" + WSTR = "WSTR" + + +class SetFieldOrderField(str, Enum): + DOWNSTREAM_SHEETS_COUNT = "DOWNSTREAM_SHEETS_COUNT" + FIELDS_COUNT = "FIELDS_COUNT" + ID = "ID" + IS_HIDDEN = "IS_HIDDEN" + NAME = "NAME" + + +class SheetOrderField(str, Enum): + DATASOURCE_FIELDS_COUNT = "DATASOURCE_FIELDS_COUNT" + DOCUMENT_VIEW_ID = "DOCUMENT_VIEW_ID" + ID = "ID" + LUID = "LUID" + NAME = "NAME" + PATH = "PATH" + SHEET_FIELD_INSTANCES_COUNT = "SHEET_FIELD_INSTANCES_COUNT" + WORKSHEET_FIELDS_COUNT = "WORKSHEET_FIELDS_COUNT" + + +class TableAdditionalDetailsOrderField(str, Enum): + ID = "ID" + + +class TableOrderField(str, Enum): + COLUMNS_COUNT = "COLUMNS_COUNT" + DOWNSTREAM_DASHBOARDS_COUNT = "DOWNSTREAM_DASHBOARDS_COUNT" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + ID = "ID" + NAME = "NAME" + + +class TableType(str, Enum): + CALCULATEDINSIGHT = "CALCULATEDINSIGHT" + DATABASETABLE = "DATABASETABLE" + DATALAKE = "DATALAKE" + DATAMODEL = "DATAMODEL" + + +class TableauSiteOrderField(str, Enum): + ID = "ID" + LUID = "LUID" + NAME = "NAME" + + +class TableauUserOrderField(str, Enum): + DOMAIN = "DOMAIN" + EMAIL = "EMAIL" + ID = "ID" + LUID = "LUID" + NAME = "NAME" + USERNAME = "USERNAME" + + +class TagOrderField(str, Enum): + ID = "ID" + NAME = "NAME" + + +class TaggableOrderField(str, Enum): + ID = "ID" + LUID = "LUID" + + +class ViewOrderField(str, Enum): + DOCUMENT_VIEW_ID = "DOCUMENT_VIEW_ID" + ID = "ID" + LUID = "LUID" + NAME = "NAME" + PATH = "PATH" + + +class VirtualConnectionOrderField(str, Enum): + CONNECTION_TYPE = "CONNECTION_TYPE" + CONTAINER_NAME = "CONTAINER_NAME" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + LUID = "LUID" + NAME = "NAME" + OWNER_COUNT = "OWNER_COUNT" + PROJECT_NAME = "PROJECT_NAME" + VIZPORTAL_URL_ID = "VIZPORTAL_URL_ID" + + +class VirtualConnectionTableOrderField(str, Enum): + COLUMNS_COUNT = "COLUMNS_COUNT" + CONTAINS_UNSUPPORTED_CUSTOM_SQL = "CONTAINS_UNSUPPORTED_CUSTOM_SQL" + DOWNSTREAM_DASHBOARDS_COUNT = "DOWNSTREAM_DASHBOARDS_COUNT" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + EXTRACT_LAST_REFRESHED_AT = "EXTRACT_LAST_REFRESHED_AT" + EXTRACT_LAST_REFRESH_TYPE = "EXTRACT_LAST_REFRESH_TYPE" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + IS_EXTRACTED = "IS_EXTRACTED" + LUID = "LUID" + NAME = "NAME" + OWNER_COUNT = "OWNER_COUNT" + VIZPORTAL_URL_ID = "VIZPORTAL_URL_ID" + + +class WarnableOrderField(str, Enum): + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + LUID = "LUID" + + +class WebDataConnectorOrderField(str, Enum): + CONNECTION_TYPE = "CONNECTION_TYPE" + DOWNSTREAM_DATASOURCES_COUNT = "DOWNSTREAM_DATASOURCES_COUNT" + DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT = "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT" + DOWNSTREAM_WORKBOOKS_COUNT = "DOWNSTREAM_WORKBOOKS_COUNT" + HAS_ACTIVE_WARNING = "HAS_ACTIVE_WARNING" + ID = "ID" + IS_CERTIFIED = "IS_CERTIFIED" + IS_EMBEDDED = "IS_EMBEDDED" + LUID = "LUID" + NAME = "NAME" + PROJECT_NAME = "PROJECT_NAME" + + +class WorkbookOrderField(str, Enum): + CONTAINER_NAME = "CONTAINER_NAME" + CONTAINS_UNSUPPORTED_CUSTOM_SQL = "CONTAINS_UNSUPPORTED_CUSTOM_SQL" + DASHBOARDS_COUNT = "DASHBOARDS_COUNT" + EMBEDDED_DATASOURCES_COUNT = "EMBEDDED_DATASOURCES_COUNT" + ID = "ID" + LUID = "LUID" + NAME = "NAME" + OWNER_COUNT = "OWNER_COUNT" + PROJECT_LUID = "PROJECT_LUID" + PROJECT_NAME = "PROJECT_NAME" + SHEETS_COUNT = "SHEETS_COUNT" + VIEWS_COUNT = "VIEWS_COUNT" + VIZPORTAL_URL_ID = "VIZPORTAL_URL_ID" diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/exceptions.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/exceptions.py new file mode 100644 index 0000000000000..9fbe116d6105b --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/exceptions.py @@ -0,0 +1,85 @@ +# Generated by ariadne-codegen + +from typing import Any, Dict, List, Optional, Union + +import httpx + + +class GraphQLClientError(Exception): + """Base exception.""" + + +class GraphQLClientHttpError(GraphQLClientError): + def __init__(self, status_code: int, response: httpx.Response) -> None: + self.status_code = status_code + self.response = response + + def __str__(self) -> str: + return f"HTTP status code: {self.status_code}" + + +class GraphQLClientInvalidResponseError(GraphQLClientError): + def __init__(self, response: httpx.Response) -> None: + self.response = response + + def __str__(self) -> str: + return "Invalid response format." + + +class GraphQLClientGraphQLError(GraphQLClientError): + def __init__( + self, + message: str, + locations: Optional[List[Dict[str, int]]] = None, + path: Optional[List[str]] = None, + extensions: Optional[Dict[str, object]] = None, + orginal: Optional[Dict[str, object]] = None, + ): + self.message = message + self.locations = locations + self.path = path + self.extensions = extensions + self.orginal = orginal + + def __str__(self) -> str: + return self.message + + @classmethod + def from_dict(cls, error: Dict[str, Any]) -> "GraphQLClientGraphQLError": + return cls( + message=error["message"], + locations=error.get("locations"), + path=error.get("path"), + extensions=error.get("extensions"), + orginal=error, + ) + + +class GraphQLClientGraphQLMultiError(GraphQLClientError): + def __init__( + self, + errors: List[GraphQLClientGraphQLError], + data: Optional[Dict[str, Any]] = None, + ): + self.errors = errors + self.data = data + + def __str__(self) -> str: + return "; ".join(str(e) for e in self.errors) + + @classmethod + def from_errors_dicts( + cls, errors_dicts: List[Dict[str, Any]], data: Optional[Dict[str, Any]] = None + ) -> "GraphQLClientGraphQLMultiError": + return cls( + errors=[GraphQLClientGraphQLError.from_dict(e) for e in errors_dicts], + data=data, + ) + + +class GraphQLClientInvalidMessageFormat(GraphQLClientError): + def __init__(self, message: Union[str, bytes]) -> None: + self.message = message + + def __str__(self) -> str: + return "Invalid message format." diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py new file mode 100644 index 0000000000000..6245e5c4bee12 --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py @@ -0,0 +1,269 @@ +# Generated by ariadne-codegen +# Source: ./tableau-queries.graphql + +from typing import Annotated, List, Literal, Optional, Union + +from pydantic import Field + +from datahub.ingestion.source.tableau.codegen_ariadne.base_model import BaseModel +from datahub.ingestion.source.tableau.codegen_ariadne.enums import RemoteType + + +class GetItemsCustomSQLTablesConnection(BaseModel): + custom_sql_tables_connection: "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnection" = Field( + alias="customSQLTablesConnection" + ) + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnection(BaseModel): + nodes: List["GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodes"] + page_info: "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionPageInfo" = ( + Field(alias="pageInfo") + ) + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodes(BaseModel): + id: str + name: Optional[str] + query: Optional[str] + columns: List[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumns" + ] + tables: List[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesTables" + ] + connection_type: Optional[str] = Field(alias="connectionType") + database: Optional[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesDatabase" + ] + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumns(BaseModel): + id: str + name: Optional[str] + remote_type: RemoteType = Field(alias="remoteType") + description: Optional[str] + referenced_by_fields: Optional[ + List[ + Optional[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFields" + ] + ] + ] = Field(alias="referencedByFields") + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFields( + BaseModel +): + datasource: Optional[ + Annotated[ + Union[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceDatasource", + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasource", + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourcePublishedDatasource", + ], + Field(discriminator="typename__"), + ] + ] + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceDatasource( + BaseModel +): + typename__: Literal["Datasource"] = Field(alias="__typename") + id: str + name: Optional[str] + upstream_tables: List[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceDatasourceUpstreamTables" + ] = Field(alias="upstreamTables") + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceDatasourceUpstreamTables( + BaseModel +): + id: str + name: Optional[str] + database: Optional[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceDatasourceUpstreamTablesDatabase" + ] + schema_: Optional[str] = Field(alias="schema") + full_name: Optional[str] = Field(alias="fullName") + connection_type: Optional[str] = Field(alias="connectionType") + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceDatasourceUpstreamTablesDatabase( + BaseModel +): + typename__: Literal[ + "CloudFile", + "DataCloud", + "Database", + "DatabaseServer", + "File", + "WebDataConnector", + ] = Field(alias="__typename") + name: Optional[str] + id: str + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasource( + BaseModel +): + typename__: Literal["EmbeddedDatasource"] = Field(alias="__typename") + id: str + name: Optional[str] + upstream_tables: List[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasourceUpstreamTables" + ] = Field(alias="upstreamTables") + workbook: Optional[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasourceWorkbook" + ] + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasourceUpstreamTables( + BaseModel +): + id: str + name: Optional[str] + database: Optional[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasourceUpstreamTablesDatabase" + ] + schema_: Optional[str] = Field(alias="schema") + full_name: Optional[str] = Field(alias="fullName") + connection_type: Optional[str] = Field(alias="connectionType") + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasourceUpstreamTablesDatabase( + BaseModel +): + typename__: Literal[ + "CloudFile", + "DataCloud", + "Database", + "DatabaseServer", + "File", + "WebDataConnector", + ] = Field(alias="__typename") + name: Optional[str] + id: str + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasourceWorkbook( + BaseModel +): + id: str + name: Optional[str] + project_name: Optional[str] = Field(alias="projectName") + luid: str + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourcePublishedDatasource( + BaseModel +): + typename__: Literal["PublishedDatasource"] = Field(alias="__typename") + id: str + name: Optional[str] + upstream_tables: List[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourcePublishedDatasourceUpstreamTables" + ] = Field(alias="upstreamTables") + project_name: Optional[str] = Field(alias="projectName") + luid: str + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourcePublishedDatasourceUpstreamTables( + BaseModel +): + id: str + name: Optional[str] + database: Optional[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourcePublishedDatasourceUpstreamTablesDatabase" + ] + schema_: Optional[str] = Field(alias="schema") + full_name: Optional[str] = Field(alias="fullName") + connection_type: Optional[str] = Field(alias="connectionType") + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourcePublishedDatasourceUpstreamTablesDatabase( + BaseModel +): + typename__: Literal[ + "CloudFile", + "DataCloud", + "Database", + "DatabaseServer", + "File", + "WebDataConnector", + ] = Field(alias="__typename") + name: Optional[str] + id: str + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesTables(BaseModel): + id: str + name: Optional[str] + database: Optional[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesTablesDatabase" + ] + schema_: Optional[str] = Field(alias="schema") + full_name: Optional[str] = Field(alias="fullName") + connection_type: Optional[str] = Field(alias="connectionType") + description: Optional[str] + columns_connection: Optional[ + "GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesTablesColumnsConnection" + ] = Field(alias="columnsConnection") + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesTablesDatabase( + BaseModel +): + typename__: Literal[ + "CloudFile", + "DataCloud", + "Database", + "DatabaseServer", + "File", + "WebDataConnector", + ] = Field(alias="__typename") + name: Optional[str] + id: str + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesTablesColumnsConnection( + BaseModel +): + total_count: int = Field(alias="totalCount") + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesDatabase( + BaseModel +): + typename__: Literal[ + "CloudFile", + "DataCloud", + "Database", + "DatabaseServer", + "File", + "WebDataConnector", + ] = Field(alias="__typename") + name: Optional[str] + id: str + connection_type: Optional[str] = Field(alias="connectionType") + + +class GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionPageInfo(BaseModel): + has_next_page: bool = Field(alias="hasNextPage") + end_cursor: Optional[str] = Field(alias="endCursor") + + +GetItemsCustomSQLTablesConnection.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnection.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodes.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumns.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFields.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceDatasource.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceDatasourceUpstreamTables.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasource.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasourceUpstreamTables.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourcePublishedDatasource.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourcePublishedDatasourceUpstreamTables.model_rebuild() +GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesTables.model_rebuild() diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_database_tables_connection.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_database_tables_connection.py new file mode 100644 index 0000000000000..ed4102217652b --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_database_tables_connection.py @@ -0,0 +1,45 @@ +# Generated by ariadne-codegen +# Source: ./tableau-queries.graphql + +from typing import List, Optional + +from pydantic import Field + +from datahub.ingestion.source.tableau.codegen_ariadne.base_model import BaseModel +from datahub.ingestion.source.tableau.codegen_ariadne.enums import RemoteType + + +class GetItemsDatabaseTablesConnection(BaseModel): + database_tables_connection: "GetItemsDatabaseTablesConnectionDatabaseTablesConnection" = Field( + alias="databaseTablesConnection" + ) + + +class GetItemsDatabaseTablesConnectionDatabaseTablesConnection(BaseModel): + nodes: List["GetItemsDatabaseTablesConnectionDatabaseTablesConnectionNodes"] + page_info: "GetItemsDatabaseTablesConnectionDatabaseTablesConnectionPageInfo" = ( + Field(alias="pageInfo") + ) + + +class GetItemsDatabaseTablesConnectionDatabaseTablesConnectionNodes(BaseModel): + id: str + is_embedded: Optional[bool] = Field(alias="isEmbedded") + columns: List[ + "GetItemsDatabaseTablesConnectionDatabaseTablesConnectionNodesColumns" + ] + + +class GetItemsDatabaseTablesConnectionDatabaseTablesConnectionNodesColumns(BaseModel): + remote_type: RemoteType = Field(alias="remoteType") + name: Optional[str] + + +class GetItemsDatabaseTablesConnectionDatabaseTablesConnectionPageInfo(BaseModel): + has_next_page: bool = Field(alias="hasNextPage") + end_cursor: Optional[str] = Field(alias="endCursor") + + +GetItemsDatabaseTablesConnection.model_rebuild() +GetItemsDatabaseTablesConnectionDatabaseTablesConnection.model_rebuild() +GetItemsDatabaseTablesConnectionDatabaseTablesConnectionNodes.model_rebuild() diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_embedded_datasources_connection.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_embedded_datasources_connection.py new file mode 100644 index 0000000000000..46b2837ca41f2 --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_embedded_datasources_connection.py @@ -0,0 +1,211 @@ +# Generated by ariadne-codegen +# Source: ./tableau-queries.graphql + +from typing import Annotated, Any, List, Literal, Optional, Union + +from pydantic import Field + +from datahub.ingestion.source.tableau.codegen_ariadne.base_model import BaseModel +from datahub.ingestion.source.tableau.codegen_ariadne.enums import ( + FieldDataType, + FieldRole, + FieldRoleCategory, +) + + +class GetItemsEmbeddedDatasourcesConnection(BaseModel): + embedded_datasources_connection: "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnection" = Field( + alias="embeddedDatasourcesConnection" + ) + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnection(BaseModel): + nodes: List[ + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodes" + ] + page_info: "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionPageInfo" = Field( + alias="pageInfo" + ) + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodes( + BaseModel +): + typename__: Literal["EmbeddedDatasource"] = Field(alias="__typename") + id: str + name: Optional[str] + has_extracts: Optional[bool] = Field(alias="hasExtracts") + extract_last_refresh_time: Optional[Any] = Field(alias="extractLastRefreshTime") + extract_last_incremental_update_time: Optional[Any] = Field( + alias="extractLastIncrementalUpdateTime" + ) + extract_last_update_time: Optional[Any] = Field(alias="extractLastUpdateTime") + downstream_sheets: List[ + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesDownstreamSheets" + ] = Field(alias="downstreamSheets") + upstream_tables: List[ + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesUpstreamTables" + ] = Field(alias="upstreamTables") + fields: List[ + Annotated[ + Union[ + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesFieldsField", + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesFieldsCalculatedField", + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesFieldsColumnField", + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesFieldsGroupField", + ], + Field(discriminator="typename__"), + ] + ] + upstream_datasources: List[ + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesUpstreamDatasources" + ] = Field(alias="upstreamDatasources") + workbook: Optional[ + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesWorkbook" + ] + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesDownstreamSheets( + BaseModel +): + name: Optional[str] + id: str + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesUpstreamTables( + BaseModel +): + id: str + name: Optional[str] + database: Optional[ + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesUpstreamTablesDatabase" + ] + schema_: Optional[str] = Field(alias="schema") + full_name: Optional[str] = Field(alias="fullName") + connection_type: Optional[str] = Field(alias="connectionType") + description: Optional[str] + columns_connection: Optional[ + "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesUpstreamTablesColumnsConnection" + ] = Field(alias="columnsConnection") + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesUpstreamTablesDatabase( + BaseModel +): + typename__: Literal[ + "CloudFile", + "DataCloud", + "Database", + "DatabaseServer", + "File", + "WebDataConnector", + ] = Field(alias="__typename") + name: Optional[str] + id: str + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesUpstreamTablesColumnsConnection( + BaseModel +): + total_count: int = Field(alias="totalCount") + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesFieldsField( + BaseModel +): + typename__: Literal[ + "BinField", + "CombinedField", + "CombinedSetField", + "DatasourceField", + "Field", + "HierarchyField", + "SetField", + ] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + is_hidden: Optional[bool] = Field(alias="isHidden") + folder_name: Optional[str] = Field(alias="folderName") + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesFieldsCalculatedField( + BaseModel +): + typename__: Literal["CalculatedField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + is_hidden: Optional[bool] = Field(alias="isHidden") + folder_name: Optional[str] = Field(alias="folderName") + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + default_format: Optional[str] = Field(alias="defaultFormat") + aggregation: Optional[str] + formula: Optional[str] + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesFieldsColumnField( + BaseModel +): + typename__: Literal["ColumnField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + is_hidden: Optional[bool] = Field(alias="isHidden") + folder_name: Optional[str] = Field(alias="folderName") + data_category: Optional[FieldRoleCategory] = Field(alias="dataCategory") + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + default_format: Optional[str] = Field(alias="defaultFormat") + aggregation: Optional[str] + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesFieldsGroupField( + BaseModel +): + typename__: Literal["GroupField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + is_hidden: Optional[bool] = Field(alias="isHidden") + folder_name: Optional[str] = Field(alias="folderName") + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesUpstreamDatasources( + BaseModel +): + id: str + name: Optional[str] + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesWorkbook( + BaseModel +): + id: str + name: Optional[str] + project_name: Optional[str] = Field(alias="projectName") + luid: str + owner: "GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesWorkbookOwner" + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesWorkbookOwner( + BaseModel +): + username: Optional[str] + + +class GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionPageInfo( + BaseModel +): + has_next_page: bool = Field(alias="hasNextPage") + end_cursor: Optional[str] = Field(alias="endCursor") + + +GetItemsEmbeddedDatasourcesConnection.model_rebuild() +GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnection.model_rebuild() +GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodes.model_rebuild() +GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesUpstreamTables.model_rebuild() +GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesWorkbook.model_rebuild() diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_fields_connection.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_fields_connection.py new file mode 100644 index 0000000000000..405da42e77323 --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_fields_connection.py @@ -0,0 +1,93 @@ +# Generated by ariadne-codegen +# Source: ./tableau-queries.graphql + +from typing import List, Literal, Optional + +from pydantic import Field + +from datahub.ingestion.source.tableau.codegen_ariadne.base_model import BaseModel + + +class GetItemsFieldsConnection(BaseModel): + fields_connection: "GetItemsFieldsConnectionFieldsConnection" = Field( + alias="fieldsConnection" + ) + + +class GetItemsFieldsConnectionFieldsConnection(BaseModel): + nodes: List["GetItemsFieldsConnectionFieldsConnectionNodes"] + page_info: "GetItemsFieldsConnectionFieldsConnectionPageInfo" = Field( + alias="pageInfo" + ) + + +class GetItemsFieldsConnectionFieldsConnectionNodes(BaseModel): + typename__: Literal[ + "BinField", + "CalculatedField", + "ColumnField", + "CombinedField", + "CombinedSetField", + "DatasourceField", + "Field", + "GroupField", + "HierarchyField", + "SetField", + ] = Field(alias="__typename") + id: str + upstream_fields: List[ + Optional["GetItemsFieldsConnectionFieldsConnectionNodesUpstreamFields"] + ] = Field(alias="upstreamFields") + upstream_columns: List[ + Optional["GetItemsFieldsConnectionFieldsConnectionNodesUpstreamColumns"] + ] = Field(alias="upstreamColumns") + + +class GetItemsFieldsConnectionFieldsConnectionNodesUpstreamFields(BaseModel): + typename__: Literal[ + "BinField", + "CalculatedField", + "ColumnField", + "CombinedField", + "CombinedSetField", + "DatasourceField", + "Field", + "GroupField", + "HierarchyField", + "SetField", + ] = Field(alias="__typename") + name: Optional[str] + datasource: Optional[ + "GetItemsFieldsConnectionFieldsConnectionNodesUpstreamFieldsDatasource" + ] + + +class GetItemsFieldsConnectionFieldsConnectionNodesUpstreamFieldsDatasource(BaseModel): + typename__: Literal["Datasource", "EmbeddedDatasource", "PublishedDatasource"] = ( + Field(alias="__typename") + ) + id: str + + +class GetItemsFieldsConnectionFieldsConnectionNodesUpstreamColumns(BaseModel): + name: Optional[str] + table: Optional["GetItemsFieldsConnectionFieldsConnectionNodesUpstreamColumnsTable"] + + +class GetItemsFieldsConnectionFieldsConnectionNodesUpstreamColumnsTable(BaseModel): + typename__: Literal[ + "CustomSQLTable", "DatabaseTable", "Table", "VirtualConnectionTable" + ] = Field(alias="__typename") + id: str + + +class GetItemsFieldsConnectionFieldsConnectionPageInfo(BaseModel): + has_next_page: bool = Field(alias="hasNextPage") + end_cursor: Optional[str] = Field(alias="endCursor") + + +GetItemsFieldsConnection.model_rebuild() +GetItemsFieldsConnectionFieldsConnection.model_rebuild() +GetItemsFieldsConnectionFieldsConnectionNodes.model_rebuild() +GetItemsFieldsConnectionFieldsConnectionNodesUpstreamFields.model_rebuild() +GetItemsFieldsConnectionFieldsConnectionNodesUpstreamColumns.model_rebuild() diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_published_datasources_connection.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_published_datasources_connection.py new file mode 100644 index 0000000000000..4425082c8ec9e --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_published_datasources_connection.py @@ -0,0 +1,193 @@ +# Generated by ariadne-codegen +# Source: ./tableau-queries.graphql + +from typing import Annotated, Any, List, Literal, Optional, Union + +from pydantic import Field + +from datahub.ingestion.source.tableau.codegen_ariadne.base_model import BaseModel +from datahub.ingestion.source.tableau.codegen_ariadne.enums import ( + FieldDataType, + FieldRole, + FieldRoleCategory, +) + + +class GetItemsPublishedDatasourcesConnection(BaseModel): + published_datasources_connection: "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnection" = Field( + alias="publishedDatasourcesConnection" + ) + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnection(BaseModel): + nodes: List[ + "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodes" + ] + page_info: "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionPageInfo" = Field( + alias="pageInfo" + ) + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodes( + BaseModel +): + typename__: Literal["PublishedDatasource"] = Field(alias="__typename") + id: str + name: Optional[str] + luid: str + has_extracts: Optional[bool] = Field(alias="hasExtracts") + extract_last_refresh_time: Optional[Any] = Field(alias="extractLastRefreshTime") + extract_last_incremental_update_time: Optional[Any] = Field( + alias="extractLastIncrementalUpdateTime" + ) + extract_last_update_time: Optional[Any] = Field(alias="extractLastUpdateTime") + upstream_tables: List[ + "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesUpstreamTables" + ] = Field(alias="upstreamTables") + fields: List[ + Annotated[ + Union[ + "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesFieldsField", + "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesFieldsCalculatedField", + "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesFieldsColumnField", + "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesFieldsGroupField", + ], + Field(discriminator="typename__"), + ] + ] + owner: ( + "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesOwner" + ) + description: Optional[str] + uri: Optional[str] + project_name: Optional[str] = Field(alias="projectName") + tags: List[ + "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesTags" + ] + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesUpstreamTables( + BaseModel +): + id: str + name: Optional[str] + database: Optional[ + "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesUpstreamTablesDatabase" + ] + schema_: Optional[str] = Field(alias="schema") + full_name: Optional[str] = Field(alias="fullName") + connection_type: Optional[str] = Field(alias="connectionType") + description: Optional[str] + columns_connection: Optional[ + "GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesUpstreamTablesColumnsConnection" + ] = Field(alias="columnsConnection") + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesUpstreamTablesDatabase( + BaseModel +): + typename__: Literal[ + "CloudFile", + "DataCloud", + "Database", + "DatabaseServer", + "File", + "WebDataConnector", + ] = Field(alias="__typename") + name: Optional[str] + id: str + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesUpstreamTablesColumnsConnection( + BaseModel +): + total_count: int = Field(alias="totalCount") + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesFieldsField( + BaseModel +): + typename__: Literal[ + "BinField", + "CombinedField", + "CombinedSetField", + "DatasourceField", + "Field", + "HierarchyField", + "SetField", + ] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + is_hidden: Optional[bool] = Field(alias="isHidden") + folder_name: Optional[str] = Field(alias="folderName") + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesFieldsCalculatedField( + BaseModel +): + typename__: Literal["CalculatedField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + is_hidden: Optional[bool] = Field(alias="isHidden") + folder_name: Optional[str] = Field(alias="folderName") + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + default_format: Optional[str] = Field(alias="defaultFormat") + aggregation: Optional[str] + formula: Optional[str] + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesFieldsColumnField( + BaseModel +): + typename__: Literal["ColumnField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + is_hidden: Optional[bool] = Field(alias="isHidden") + folder_name: Optional[str] = Field(alias="folderName") + data_category: Optional[FieldRoleCategory] = Field(alias="dataCategory") + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + default_format: Optional[str] = Field(alias="defaultFormat") + aggregation: Optional[str] + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesFieldsGroupField( + BaseModel +): + typename__: Literal["GroupField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + is_hidden: Optional[bool] = Field(alias="isHidden") + folder_name: Optional[str] = Field(alias="folderName") + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesOwner( + BaseModel +): + username: Optional[str] + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesTags( + BaseModel +): + name: Optional[str] + + +class GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionPageInfo( + BaseModel +): + has_next_page: bool = Field(alias="hasNextPage") + end_cursor: Optional[str] = Field(alias="endCursor") + + +GetItemsPublishedDatasourcesConnection.model_rebuild() +GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnection.model_rebuild() +GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodes.model_rebuild() +GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesUpstreamTables.model_rebuild() diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py new file mode 100644 index 0000000000000..8628ecbec4212 --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py @@ -0,0 +1,291 @@ +# Generated by ariadne-codegen +# Source: ./tableau-queries.graphql + +from typing import Annotated, Any, List, Literal, Optional, Union + +from pydantic import Field + +from datahub.ingestion.source.tableau.codegen_ariadne.base_model import BaseModel +from datahub.ingestion.source.tableau.codegen_ariadne.enums import ( + FieldDataType, + FieldRole, + FieldRoleCategory, +) + + +class GetItemsSheetsConnection(BaseModel): + sheets_connection: "GetItemsSheetsConnectionSheetsConnection" = Field( + alias="sheetsConnection" + ) + + +class GetItemsSheetsConnectionSheetsConnection(BaseModel): + nodes: List["GetItemsSheetsConnectionSheetsConnectionNodes"] + page_info: "GetItemsSheetsConnectionSheetsConnectionPageInfo" = Field( + alias="pageInfo" + ) + + +class GetItemsSheetsConnectionSheetsConnectionNodes(BaseModel): + id: str + name: Optional[str] + path: Optional[str] + luid: str + created_at: Any = Field(alias="createdAt") + updated_at: Any = Field(alias="updatedAt") + tags: List["GetItemsSheetsConnectionSheetsConnectionNodesTags"] + contained_in_dashboards: Optional[ + List[ + Optional[ + "GetItemsSheetsConnectionSheetsConnectionNodesContainedInDashboards" + ] + ] + ] = Field(alias="containedInDashboards") + workbook: Optional["GetItemsSheetsConnectionSheetsConnectionNodesWorkbook"] + datasource_fields: Optional[ + List[ + Optional[ + Annotated[ + Union[ + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsField", + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsCalculatedField", + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsColumnField", + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceField", + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsGroupField", + ], + Field(discriminator="typename__"), + ] + ] + ] + ] = Field(alias="datasourceFields") + + +class GetItemsSheetsConnectionSheetsConnectionNodesTags(BaseModel): + name: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesContainedInDashboards(BaseModel): + name: Optional[str] + path: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesWorkbook(BaseModel): + id: str + name: Optional[str] + project_name: Optional[str] = Field(alias="projectName") + luid: str + owner: "GetItemsSheetsConnectionSheetsConnectionNodesWorkbookOwner" + + +class GetItemsSheetsConnectionSheetsConnectionNodesWorkbookOwner(BaseModel): + username: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsField(BaseModel): + typename__: Literal[ + "BinField", + "CombinedField", + "CombinedSetField", + "Field", + "HierarchyField", + "SetField", + ] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + datasource: Optional[ + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsFieldDatasource" + ] + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsFieldDatasource( + BaseModel +): + typename__: Literal["Datasource", "EmbeddedDatasource", "PublishedDatasource"] = ( + Field(alias="__typename") + ) + id: str + name: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsCalculatedField( + BaseModel +): + typename__: Literal["CalculatedField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + datasource: Optional[ + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsCalculatedFieldDatasource" + ] + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + aggregation: Optional[str] + formula: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsCalculatedFieldDatasource( + BaseModel +): + typename__: Literal["Datasource", "EmbeddedDatasource", "PublishedDatasource"] = ( + Field(alias="__typename") + ) + id: str + name: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsColumnField( + BaseModel +): + typename__: Literal["ColumnField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + datasource: Optional[ + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsColumnFieldDatasource" + ] + data_category: Optional[FieldRoleCategory] = Field(alias="dataCategory") + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + aggregation: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsColumnFieldDatasource( + BaseModel +): + typename__: Literal["Datasource", "EmbeddedDatasource", "PublishedDatasource"] = ( + Field(alias="__typename") + ) + id: str + name: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceField( + BaseModel +): + typename__: Literal["DatasourceField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + datasource: Optional[ + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceFieldDatasource" + ] + remote_field: Optional[ + Annotated[ + Union[ + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceFieldRemoteFieldField", + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceFieldRemoteFieldCalculatedField", + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceFieldRemoteFieldColumnField", + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceFieldRemoteFieldGroupField", + ], + Field(discriminator="typename__"), + ] + ] = Field(alias="remoteField") + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceFieldDatasource( + BaseModel +): + typename__: Literal["Datasource", "EmbeddedDatasource", "PublishedDatasource"] = ( + Field(alias="__typename") + ) + id: str + name: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceFieldRemoteFieldField( + BaseModel +): + typename__: Literal[ + "BinField", + "CombinedField", + "CombinedSetField", + "DatasourceField", + "Field", + "HierarchyField", + "SetField", + ] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + folder_name: Optional[str] = Field(alias="folderName") + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceFieldRemoteFieldCalculatedField( + BaseModel +): + typename__: Literal["CalculatedField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + folder_name: Optional[str] = Field(alias="folderName") + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + aggregation: Optional[str] + formula: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceFieldRemoteFieldColumnField( + BaseModel +): + typename__: Literal["ColumnField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + folder_name: Optional[str] = Field(alias="folderName") + data_category: Optional[FieldRoleCategory] = Field(alias="dataCategory") + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + aggregation: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceFieldRemoteFieldGroupField( + BaseModel +): + typename__: Literal["GroupField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + folder_name: Optional[str] = Field(alias="folderName") + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsGroupField( + BaseModel +): + typename__: Literal["GroupField"] = Field(alias="__typename") + id: str + name: Optional[str] + description: Optional[str] + datasource: Optional[ + "GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsGroupFieldDatasource" + ] + role: Optional[FieldRole] + data_type: Optional[FieldDataType] = Field(alias="dataType") + + +class GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsGroupFieldDatasource( + BaseModel +): + typename__: Literal["Datasource", "EmbeddedDatasource", "PublishedDatasource"] = ( + Field(alias="__typename") + ) + id: str + name: Optional[str] + + +class GetItemsSheetsConnectionSheetsConnectionPageInfo(BaseModel): + has_next_page: bool = Field(alias="hasNextPage") + end_cursor: Optional[str] = Field(alias="endCursor") + + +GetItemsSheetsConnection.model_rebuild() +GetItemsSheetsConnectionSheetsConnection.model_rebuild() +GetItemsSheetsConnectionSheetsConnectionNodes.model_rebuild() +GetItemsSheetsConnectionSheetsConnectionNodesWorkbook.model_rebuild() +GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsField.model_rebuild() +GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsCalculatedField.model_rebuild() +GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsColumnField.model_rebuild() +GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceField.model_rebuild() +GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsGroupField.model_rebuild() diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py new file mode 100644 index 0000000000000..ac4fa5d865ee4 --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py @@ -0,0 +1,70 @@ +# Generated by ariadne-codegen +# Source: ./tableau-queries.graphql + +from typing import Any, List, Optional + +from pydantic import Field + +from datahub.ingestion.source.tableau.codegen_ariadne.base_model import BaseModel + + +class GetItemsWorkbooksConnection(BaseModel): + workbooks_connection: "GetItemsWorkbooksConnectionWorkbooksConnection" = Field( + alias="workbooksConnection" + ) + + +class GetItemsWorkbooksConnectionWorkbooksConnection(BaseModel): + nodes: List["GetItemsWorkbooksConnectionWorkbooksConnectionNodes"] + page_info: "GetItemsWorkbooksConnectionWorkbooksConnectionPageInfo" = Field( + alias="pageInfo" + ) + + +class GetItemsWorkbooksConnectionWorkbooksConnectionNodes(BaseModel): + id: str + name: Optional[str] + luid: str + uri: Optional[str] + project_name: Optional[str] = Field(alias="projectName") + owner: "GetItemsWorkbooksConnectionWorkbooksConnectionNodesOwner" + description: Optional[str] + uri: Optional[str] + created_at: Any = Field(alias="createdAt") + updated_at: Any = Field(alias="updatedAt") + tags: List["GetItemsWorkbooksConnectionWorkbooksConnectionNodesTags"] + sheets: List["GetItemsWorkbooksConnectionWorkbooksConnectionNodesSheets"] + dashboards: List["GetItemsWorkbooksConnectionWorkbooksConnectionNodesDashboards"] + embedded_datasources: List[ + "GetItemsWorkbooksConnectionWorkbooksConnectionNodesEmbeddedDatasources" + ] = Field(alias="embeddedDatasources") + + +class GetItemsWorkbooksConnectionWorkbooksConnectionNodesOwner(BaseModel): + username: Optional[str] + + +class GetItemsWorkbooksConnectionWorkbooksConnectionNodesTags(BaseModel): + name: Optional[str] + + +class GetItemsWorkbooksConnectionWorkbooksConnectionNodesSheets(BaseModel): + id: str + + +class GetItemsWorkbooksConnectionWorkbooksConnectionNodesDashboards(BaseModel): + id: str + + +class GetItemsWorkbooksConnectionWorkbooksConnectionNodesEmbeddedDatasources(BaseModel): + id: str + + +class GetItemsWorkbooksConnectionWorkbooksConnectionPageInfo(BaseModel): + has_next_page: bool = Field(alias="hasNextPage") + end_cursor: Optional[str] = Field(alias="endCursor") + + +GetItemsWorkbooksConnection.model_rebuild() +GetItemsWorkbooksConnectionWorkbooksConnection.model_rebuild() +GetItemsWorkbooksConnectionWorkbooksConnectionNodes.model_rebuild() diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/input_types.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/input_types.py new file mode 100644 index 0000000000000..3f3fc569620be --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/input_types.py @@ -0,0 +1,1437 @@ +# Generated by ariadne-codegen +# Source: ../../schemas/tableau/schema.graphql + +from typing import Any, List, Optional + +from pydantic import Field + +from datahub.ingestion.source.tableau.codegen_ariadne.base_model import BaseModel +from datahub.ingestion.source.tableau.codegen_ariadne.enums import ( + AnalyticsFieldOrderField, + AskDataExtensionOrderField, + BinFieldOrderField, + CalculatedFieldOrderField, + CanHaveLabelsOrderField, + CertifiableOrderField, + CloudFileOrderField, + ColumnFieldOrderField, + ColumnOrderField, + CombinedFieldOrderField, + CombinedSetFieldOrderField, + CustomSQLTableOrderField, + DashboardOrderField, + DatabaseOrderField, + DatabaseServerOrderField, + DatabaseTableOrderField, + DataCloudOrderField, + DataFieldOrderField, + DataQualityCertificationOrderField, + DataQualityWarningOrderField, + DatasourceFieldOrderField, + DatasourceFilterOrderField, + DatasourceOrderField, + EmbeddedDatasourceOrderField, + FieldOrderField, + FieldReferencingFieldOrderField, + FileOrderField, + FlowColumnInputFieldOrderField, + FlowColumnOutputFieldOrderField, + FlowFieldInputFieldOrderField, + FlowFieldOutputFieldOrderField, + FlowInputFieldOrderField, + FlowOrderField, + FlowOutputFieldOrderField, + FlowOutputStepOrderField, + GenericLabelOrderField, + GroupFieldOrderField, + HierarchyFieldOrderField, + LabelOrderField, + LensFieldOrderField, + LensOrderField, + LinkedFlowOrderField, + MetricDefinitionOrderField, + MetricOrderField, + NodeOrderField, + OrderDirection, + ParameterOrderField, + PublishedDatasourceOrderField, + SetFieldOrderField, + SheetOrderField, + TableAdditionalDetailsOrderField, + TableauSiteOrderField, + TableauUserOrderField, + TableOrderField, + TaggableOrderField, + TagOrderField, + ViewOrderField, + VirtualConnectionOrderField, + VirtualConnectionTableOrderField, + WarnableOrderField, + WebDataConnectorOrderField, + WorkbookOrderField, +) + + +class AnalyticsFieldSortOrder(BaseModel): + direction: OrderDirection + field: AnalyticsFieldOrderField + + +class AnalyticsField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class AskDataExtensionSortOrder(BaseModel): + direction: OrderDirection + field: AskDataExtensionOrderField + + +class AskDataExtension_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class AskDataExtension_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class BinFieldSortOrder(BaseModel): + direction: OrderDirection + field: BinFieldOrderField + + +class BinField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_hidden: Optional[bool] = Field(alias="isHidden", default=None) + is_hidden_within: Optional[List[Optional[bool]]] = Field( + alias="isHiddenWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class BinField_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class CalculatedFieldSortOrder(BaseModel): + direction: OrderDirection + field: CalculatedFieldOrderField + + +class CalculatedField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_hidden: Optional[bool] = Field(alias="isHidden", default=None) + is_hidden_within: Optional[List[Optional[bool]]] = Field( + alias="isHiddenWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class CalculatedField_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class CanHaveLabelsSortOrder(BaseModel): + direction: OrderDirection + field: CanHaveLabelsOrderField + + +class CanHaveLabels_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + + +class CertifiableSortOrder(BaseModel): + direction: OrderDirection + field: CertifiableOrderField + + +class Certifiable_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + + +class CloudFileSortOrder(BaseModel): + direction: OrderDirection + field: CloudFileOrderField + + +class CloudFile_Filter(BaseModel): + connection_type: Optional[str] = Field(alias="connectionType", default=None) + connection_type_within: Optional[List[Optional[str]]] = Field( + alias="connectionTypeWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + is_embedded: Optional[bool] = Field(alias="isEmbedded", default=None) + is_embedded_within: Optional[List[Optional[bool]]] = Field( + alias="isEmbeddedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + text: Optional[str] = None + + +class ColumnFieldSortOrder(BaseModel): + direction: OrderDirection + field: ColumnFieldOrderField + + +class ColumnField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_hidden: Optional[bool] = Field(alias="isHidden", default=None) + is_hidden_within: Optional[List[Optional[bool]]] = Field( + alias="isHiddenWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class ColumnField_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class ColumnSortOrder(BaseModel): + direction: OrderDirection + field: ColumnOrderField + + +class Column_Filter(BaseModel): + display_name: Optional[str] = Field(alias="displayName", default=None) + display_name_within: Optional[List[Optional[str]]] = Field( + alias="displayNameWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class Column_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class CombinedFieldSortOrder(BaseModel): + direction: OrderDirection + field: CombinedFieldOrderField + + +class CombinedField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_hidden: Optional[bool] = Field(alias="isHidden", default=None) + is_hidden_within: Optional[List[Optional[bool]]] = Field( + alias="isHiddenWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class CombinedField_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class CombinedSetFieldSortOrder(BaseModel): + direction: OrderDirection + field: CombinedSetFieldOrderField + + +class CombinedSetField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_hidden: Optional[bool] = Field(alias="isHidden", default=None) + is_hidden_within: Optional[List[Optional[bool]]] = Field( + alias="isHiddenWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class CombinedSetField_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class CustomSQLTableSortOrder(BaseModel): + direction: OrderDirection + field: CustomSQLTableOrderField + + +class CustomSQLTable_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_unsupported_custom_sql: Optional[bool] = Field( + alias="isUnsupportedCustomSql", default=None + ) + is_unsupported_custom_sql_within: Optional[List[Optional[bool]]] = Field( + alias="isUnsupportedCustomSqlWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class DashboardSortOrder(BaseModel): + direction: OrderDirection + field: DashboardOrderField + + +class Dashboard_Filter(BaseModel): + document_view_id: Optional[str] = Field(alias="documentViewId", default=None) + document_view_id_within: Optional[List[Optional[str]]] = Field( + alias="documentViewIdWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + path: Optional[str] = None + path_within: Optional[List[Optional[str]]] = Field(alias="pathWithin", default=None) + + +class DataCloudSortOrder(BaseModel): + direction: OrderDirection + field: DataCloudOrderField + + +class DataCloud_Filter(BaseModel): + connection_type: Optional[str] = Field(alias="connectionType", default=None) + connection_type_within: Optional[List[Optional[str]]] = Field( + alias="connectionTypeWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + is_embedded: Optional[bool] = Field(alias="isEmbedded", default=None) + is_embedded_within: Optional[List[Optional[bool]]] = Field( + alias="isEmbeddedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + text: Optional[str] = None + + +class DataFieldSortOrder(BaseModel): + direction: OrderDirection + field: DataFieldOrderField + + +class DataField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class DataQualityCertificationSortOrder(BaseModel): + direction: OrderDirection + field: DataQualityCertificationOrderField + + +class DataQualityCertification_Filter(BaseModel): + category: Optional[str] = None + category_within: Optional[List[Optional[str]]] = Field( + alias="categoryWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_active: Optional[bool] = Field(alias="isActive", default=None) + is_active_within: Optional[List[Optional[bool]]] = Field( + alias="isActiveWithin", default=None + ) + is_elevated: Optional[bool] = Field(alias="isElevated", default=None) + is_elevated_within: Optional[List[Optional[bool]]] = Field( + alias="isElevatedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + value: Optional[str] = None + value_within: Optional[List[Optional[str]]] = Field( + alias="valueWithin", default=None + ) + + +class DataQualityWarningSortOrder(BaseModel): + direction: OrderDirection + field: DataQualityWarningOrderField + + +class DataQualityWarning_Filter(BaseModel): + category: Optional[str] = None + category_within: Optional[List[Optional[str]]] = Field( + alias="categoryWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_active: Optional[bool] = Field(alias="isActive", default=None) + is_active_within: Optional[List[Optional[bool]]] = Field( + alias="isActiveWithin", default=None + ) + is_elevated: Optional[bool] = Field(alias="isElevated", default=None) + is_elevated_within: Optional[List[Optional[bool]]] = Field( + alias="isElevatedWithin", default=None + ) + is_severe: Optional[bool] = Field(alias="isSevere", default=None) + is_severe_within: Optional[List[Optional[bool]]] = Field( + alias="isSevereWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + value: Optional[str] = None + value_within: Optional[List[Optional[str]]] = Field( + alias="valueWithin", default=None + ) + warning_type: Optional[str] = Field(alias="warningType", default=None) + warning_type_within: Optional[List[Optional[str]]] = Field( + alias="warningTypeWithin", default=None + ) + + +class DatabaseServerSortOrder(BaseModel): + direction: OrderDirection + field: DatabaseServerOrderField + + +class DatabaseServer_Filter(BaseModel): + connection_type: Optional[str] = Field(alias="connectionType", default=None) + connection_type_within: Optional[List[Optional[str]]] = Field( + alias="connectionTypeWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + host_name: Optional[str] = Field(alias="hostName", default=None) + host_name_within: Optional[List[Optional[str]]] = Field( + alias="hostNameWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + is_embedded: Optional[bool] = Field(alias="isEmbedded", default=None) + is_embedded_within: Optional[List[Optional[bool]]] = Field( + alias="isEmbeddedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + text: Optional[str] = None + + +class DatabaseSortOrder(BaseModel): + direction: OrderDirection + field: DatabaseOrderField + + +class DatabaseTableSortOrder(BaseModel): + direction: OrderDirection + field: DatabaseTableOrderField + + +class DatabaseTable_Filter(BaseModel): + connection_type: Optional[str] = Field(alias="connectionType", default=None) + connection_type_within: Optional[List[Optional[str]]] = Field( + alias="connectionTypeWithin", default=None + ) + full_name: Optional[str] = Field(alias="fullName", default=None) + full_name_within: Optional[List[Optional[str]]] = Field( + alias="fullNameWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + is_embedded: Optional[bool] = Field(alias="isEmbedded", default=None) + is_embedded_within: Optional[List[Optional[bool]]] = Field( + alias="isEmbeddedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + schema_: Optional[str] = Field(alias="schema", default=None) + schema_within: Optional[List[Optional[str]]] = Field( + alias="schemaWithin", default=None + ) + text: Optional[str] = None + + +class Database_Filter(BaseModel): + connection_type: Optional[str] = Field(alias="connectionType", default=None) + connection_type_within: Optional[List[Optional[str]]] = Field( + alias="connectionTypeWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + is_embedded: Optional[bool] = Field(alias="isEmbedded", default=None) + is_embedded_within: Optional[List[Optional[bool]]] = Field( + alias="isEmbeddedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + text: Optional[str] = None + + +class DatasourceFieldSortOrder(BaseModel): + direction: OrderDirection + field: DatasourceFieldOrderField + + +class DatasourceField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_hidden: Optional[bool] = Field(alias="isHidden", default=None) + is_hidden_within: Optional[List[Optional[bool]]] = Field( + alias="isHiddenWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class DatasourceField_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class DatasourceFilterSortOrder(BaseModel): + direction: OrderDirection + field: DatasourceFilterOrderField + + +class DatasourceFilter_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class DatasourceSortOrder(BaseModel): + direction: OrderDirection + field: DatasourceOrderField + + +class Datasource_Filter(BaseModel): + contains_unsupported_custom_sql: Optional[bool] = Field( + alias="containsUnsupportedCustomSql", default=None + ) + contains_unsupported_custom_sql_within: Optional[List[Optional[bool]]] = Field( + alias="containsUnsupportedCustomSqlWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class EmbeddedDatasourceSortOrder(BaseModel): + direction: OrderDirection + field: EmbeddedDatasourceOrderField + + +class EmbeddedDatasource_Filter(BaseModel): + contains_unsupported_custom_sql: Optional[bool] = Field( + alias="containsUnsupportedCustomSql", default=None + ) + contains_unsupported_custom_sql_within: Optional[List[Optional[bool]]] = Field( + alias="containsUnsupportedCustomSqlWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class ExtractType_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class FieldDataType_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class FieldReferencingFieldSortOrder(BaseModel): + direction: OrderDirection + field: FieldReferencingFieldOrderField + + +class FieldReferencingField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class FieldRoleCategory_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class FieldRole_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class FieldSortOrder(BaseModel): + direction: OrderDirection + field: FieldOrderField + + +class Field_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_hidden: Optional[bool] = Field(alias="isHidden", default=None) + is_hidden_within: Optional[List[Optional[bool]]] = Field( + alias="isHiddenWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class Field_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class FileSortOrder(BaseModel): + direction: OrderDirection + field: FileOrderField + + +class File_Filter(BaseModel): + connection_type: Optional[str] = Field(alias="connectionType", default=None) + connection_type_within: Optional[List[Optional[str]]] = Field( + alias="connectionTypeWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + is_embedded: Optional[bool] = Field(alias="isEmbedded", default=None) + is_embedded_within: Optional[List[Optional[bool]]] = Field( + alias="isEmbeddedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + text: Optional[str] = None + + +class FlowColumnInputFieldSortOrder(BaseModel): + direction: OrderDirection + field: FlowColumnInputFieldOrderField + + +class FlowColumnInputField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class FlowColumnOutputFieldSortOrder(BaseModel): + direction: OrderDirection + field: FlowColumnOutputFieldOrderField + + +class FlowColumnOutputField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class FlowFieldInputFieldSortOrder(BaseModel): + direction: OrderDirection + field: FlowFieldInputFieldOrderField + + +class FlowFieldInputField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class FlowFieldOutputFieldSortOrder(BaseModel): + direction: OrderDirection + field: FlowFieldOutputFieldOrderField + + +class FlowFieldOutputField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class FlowInputFieldSortOrder(BaseModel): + direction: OrderDirection + field: FlowInputFieldOrderField + + +class FlowInputField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class FlowOutputFieldSortOrder(BaseModel): + direction: OrderDirection + field: FlowOutputFieldOrderField + + +class FlowOutputField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class FlowOutputStepSortOrder(BaseModel): + direction: OrderDirection + field: FlowOutputStepOrderField + + +class FlowOutputStep_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class FlowSortOrder(BaseModel): + direction: OrderDirection + field: FlowOrderField + + +class Flow_Filter(BaseModel): + container_name: Optional[str] = Field(alias="containerName", default=None) + container_name_within: Optional[List[Optional[str]]] = Field( + alias="containerNameWithin", default=None + ) + contains_unsupported_custom_sql: Optional[bool] = Field( + alias="containsUnsupportedCustomSql", default=None + ) + contains_unsupported_custom_sql_within: Optional[List[Optional[bool]]] = Field( + alias="containsUnsupportedCustomSqlWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + vizportal_url_id: Optional[str] = Field(alias="vizportalUrlId", default=None) + vizportal_url_id_within: Optional[List[Optional[str]]] = Field( + alias="vizportalUrlIdWithin", default=None + ) + + +class GenericLabelSortOrder(BaseModel): + direction: OrderDirection + field: GenericLabelOrderField + + +class GenericLabel_Filter(BaseModel): + category: Optional[str] = None + category_within: Optional[List[Optional[str]]] = Field( + alias="categoryWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_active: Optional[bool] = Field(alias="isActive", default=None) + is_active_within: Optional[List[Optional[bool]]] = Field( + alias="isActiveWithin", default=None + ) + is_elevated: Optional[bool] = Field(alias="isElevated", default=None) + is_elevated_within: Optional[List[Optional[bool]]] = Field( + alias="isElevatedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + value: Optional[str] = None + value_within: Optional[List[Optional[str]]] = Field( + alias="valueWithin", default=None + ) + + +class GroupFieldSortOrder(BaseModel): + direction: OrderDirection + field: GroupFieldOrderField + + +class GroupField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_hidden: Optional[bool] = Field(alias="isHidden", default=None) + is_hidden_within: Optional[List[Optional[bool]]] = Field( + alias="isHiddenWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class GroupField_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class HierarchyFieldSortOrder(BaseModel): + direction: OrderDirection + field: HierarchyFieldOrderField + + +class HierarchyField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_hidden: Optional[bool] = Field(alias="isHidden", default=None) + is_hidden_within: Optional[List[Optional[bool]]] = Field( + alias="isHiddenWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class HierarchyField_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class LabelSortOrder(BaseModel): + direction: OrderDirection + field: LabelOrderField + + +class Label_Filter(BaseModel): + category: Optional[str] = None + category_within: Optional[List[Optional[str]]] = Field( + alias="categoryWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_active: Optional[bool] = Field(alias="isActive", default=None) + is_active_within: Optional[List[Optional[bool]]] = Field( + alias="isActiveWithin", default=None + ) + is_elevated: Optional[bool] = Field(alias="isElevated", default=None) + is_elevated_within: Optional[List[Optional[bool]]] = Field( + alias="isElevatedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + value: Optional[str] = None + value_within: Optional[List[Optional[str]]] = Field( + alias="valueWithin", default=None + ) + + +class LensFieldSortOrder(BaseModel): + direction: OrderDirection + field: LensFieldOrderField + + +class LensField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class LensField_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class LensSortOrder(BaseModel): + direction: OrderDirection + field: LensOrderField + + +class Lens_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + vizportal_url_id: Optional[str] = Field(alias="vizportalUrlId", default=None) + vizportal_url_id_within: Optional[List[Optional[str]]] = Field( + alias="vizportalUrlIdWithin", default=None + ) + + +class LinkedFlowSortOrder(BaseModel): + direction: OrderDirection + field: LinkedFlowOrderField + + +class LinkedFlow_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class MetricDefinitionSortOrder(BaseModel): + direction: OrderDirection + field: MetricDefinitionOrderField + + +class MetricDefinition_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class MetricSortOrder(BaseModel): + direction: OrderDirection + field: MetricOrderField + + +class Metric_Filter(BaseModel): + container_name: Optional[str] = Field(alias="containerName", default=None) + container_name_within: Optional[List[Optional[str]]] = Field( + alias="containerNameWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + vizportal_url_id: Optional[str] = Field(alias="vizportalUrlId", default=None) + vizportal_url_id_within: Optional[List[Optional[str]]] = Field( + alias="vizportalUrlIdWithin", default=None + ) + + +class NodeSortOrder(BaseModel): + direction: OrderDirection + field: NodeOrderField + + +class Node_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class ParameterSortOrder(BaseModel): + direction: OrderDirection + field: ParameterOrderField + + +class Parameter_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + parent_name: Optional[str] = Field(alias="parentName", default=None) + parent_name_within: Optional[List[Optional[str]]] = Field( + alias="parentNameWithin", default=None + ) + + +class PublishedDatasourceSortOrder(BaseModel): + direction: OrderDirection + field: PublishedDatasourceOrderField + + +class PublishedDatasource_Filter(BaseModel): + container_name: Optional[str] = Field(alias="containerName", default=None) + container_name_within: Optional[List[Optional[str]]] = Field( + alias="containerNameWithin", default=None + ) + contains_unsupported_custom_sql: Optional[bool] = Field( + alias="containsUnsupportedCustomSql", default=None + ) + contains_unsupported_custom_sql_within: Optional[List[Optional[bool]]] = Field( + alias="containsUnsupportedCustomSqlWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + vizportal_url_id: Optional[str] = Field(alias="vizportalUrlId", default=None) + vizportal_url_id_within: Optional[List[Optional[str]]] = Field( + alias="vizportalUrlIdWithin", default=None + ) + + +class RemoteType_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class SetFieldSortOrder(BaseModel): + direction: OrderDirection + field: SetFieldOrderField + + +class SetField_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_hidden: Optional[bool] = Field(alias="isHidden", default=None) + is_hidden_within: Optional[List[Optional[bool]]] = Field( + alias="isHiddenWithin", default=None + ) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class SetField_Required_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class SheetSortOrder(BaseModel): + direction: OrderDirection + field: SheetOrderField + + +class Sheet_Filter(BaseModel): + document_view_id: Optional[str] = Field(alias="documentViewId", default=None) + document_view_id_within: Optional[List[Optional[str]]] = Field( + alias="documentViewIdWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + path: Optional[str] = None + path_within: Optional[List[Optional[str]]] = Field(alias="pathWithin", default=None) + + +class TableAdditionalDetailsSortOrder(BaseModel): + direction: OrderDirection + field: TableAdditionalDetailsOrderField + + +class TableAdditionalDetails_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class TableSortOrder(BaseModel): + direction: OrderDirection + field: TableOrderField + + +class TableType_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + + +class Table_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class TableauSiteSortOrder(BaseModel): + direction: OrderDirection + field: TableauSiteOrderField + + +class TableauSite_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + + +class TableauUserSortOrder(BaseModel): + direction: OrderDirection + field: TableauUserOrderField + + +class TableauUser_Filter(BaseModel): + domain: Optional[str] = None + domain_within: Optional[List[Optional[str]]] = Field( + alias="domainWithin", default=None + ) + email: Optional[str] = None + email_within: Optional[List[Optional[str]]] = Field( + alias="emailWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + username: Optional[str] = None + username_within: Optional[List[Optional[str]]] = Field( + alias="usernameWithin", default=None + ) + + +class TagSortOrder(BaseModel): + direction: OrderDirection + field: TagOrderField + + +class Tag_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + text: Optional[str] = None + + +class TaggableSortOrder(BaseModel): + direction: OrderDirection + field: TaggableOrderField + + +class Taggable_Filter(BaseModel): + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + + +class ViewSortOrder(BaseModel): + direction: OrderDirection + field: ViewOrderField + + +class View_Filter(BaseModel): + document_view_id: Optional[str] = Field(alias="documentViewId", default=None) + document_view_id_within: Optional[List[Optional[str]]] = Field( + alias="documentViewIdWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + path: Optional[str] = None + path_within: Optional[List[Optional[str]]] = Field(alias="pathWithin", default=None) + + +class VirtualConnectionSortOrder(BaseModel): + direction: OrderDirection + field: VirtualConnectionOrderField + + +class VirtualConnectionTableSortOrder(BaseModel): + direction: OrderDirection + field: VirtualConnectionTableOrderField + + +class VirtualConnectionTable_Filter(BaseModel): + contains_unsupported_custom_sql: Optional[bool] = Field( + alias="containsUnsupportedCustomSql", default=None + ) + contains_unsupported_custom_sql_within: Optional[List[Optional[bool]]] = Field( + alias="containsUnsupportedCustomSqlWithin", default=None + ) + extract_last_refreshed_at: Optional[Any] = Field( + alias="extractLastRefreshedAt", default=None + ) + extract_last_refreshed_at_within: Optional[List[Optional[Any]]] = Field( + alias="extractLastRefreshedAtWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + is_extracted: Optional[bool] = Field(alias="isExtracted", default=None) + is_extracted_within: Optional[List[Optional[bool]]] = Field( + alias="isExtractedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + vizportal_url_id: Optional[str] = Field(alias="vizportalUrlId", default=None) + vizportal_url_id_within: Optional[List[Optional[str]]] = Field( + alias="vizportalUrlIdWithin", default=None + ) + + +class VirtualConnection_Filter(BaseModel): + connection_type: Optional[str] = Field(alias="connectionType", default=None) + connection_type_within: Optional[List[Optional[str]]] = Field( + alias="connectionTypeWithin", default=None + ) + container_name: Optional[str] = Field(alias="containerName", default=None) + container_name_within: Optional[List[Optional[str]]] = Field( + alias="containerNameWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + vizportal_url_id: Optional[str] = Field(alias="vizportalUrlId", default=None) + vizportal_url_id_within: Optional[List[Optional[str]]] = Field( + alias="vizportalUrlIdWithin", default=None + ) + + +class WarnableSortOrder(BaseModel): + direction: OrderDirection + field: WarnableOrderField + + +class Warnable_Filter(BaseModel): + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + + +class WebDataConnectorSortOrder(BaseModel): + direction: OrderDirection + field: WebDataConnectorOrderField + + +class WebDataConnector_Filter(BaseModel): + connection_type: Optional[str] = Field(alias="connectionType", default=None) + connection_type_within: Optional[List[Optional[str]]] = Field( + alias="connectionTypeWithin", default=None + ) + has_active_warning: Optional[bool] = Field(alias="hasActiveWarning", default=None) + has_active_warning_within: Optional[List[Optional[bool]]] = Field( + alias="hasActiveWarningWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + is_certified: Optional[bool] = Field(alias="isCertified", default=None) + is_certified_within: Optional[List[Optional[bool]]] = Field( + alias="isCertifiedWithin", default=None + ) + is_embedded: Optional[bool] = Field(alias="isEmbedded", default=None) + is_embedded_within: Optional[List[Optional[bool]]] = Field( + alias="isEmbeddedWithin", default=None + ) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + text: Optional[str] = None + + +class WorkbookSortOrder(BaseModel): + direction: OrderDirection + field: WorkbookOrderField + + +class Workbook_Filter(BaseModel): + container_name: Optional[str] = Field(alias="containerName", default=None) + container_name_within: Optional[List[Optional[str]]] = Field( + alias="containerNameWithin", default=None + ) + contains_unsupported_custom_sql: Optional[bool] = Field( + alias="containsUnsupportedCustomSql", default=None + ) + contains_unsupported_custom_sql_within: Optional[List[Optional[bool]]] = Field( + alias="containsUnsupportedCustomSqlWithin", default=None + ) + id: Optional[str] = None + id_within: Optional[List[Optional[str]]] = Field(alias="idWithin", default=None) + luid: Optional[str] = None + luid_within: Optional[List[Optional[str]]] = Field(alias="luidWithin", default=None) + name: Optional[str] = None + name_within: Optional[List[Optional[str]]] = Field(alias="nameWithin", default=None) + project_luid: Optional[str] = Field(alias="projectLuid", default=None) + project_luid_within: Optional[List[Optional[str]]] = Field( + alias="projectLuidWithin", default=None + ) + project_name: Optional[str] = Field(alias="projectName", default=None) + project_name_within: Optional[List[Optional[str]]] = Field( + alias="projectNameWithin", default=None + ) + vizportal_url_id: Optional[str] = Field(alias="vizportalUrlId", default=None) + vizportal_url_id_within: Optional[List[Optional[str]]] = Field( + alias="vizportalUrlIdWithin", default=None + ) diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/__init__.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/__init__.py new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_operations.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_operations.py new file mode 100644 index 0000000000000..9713dbee4ca4e --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_operations.py @@ -0,0 +1,584 @@ +import sgqlc.operation +import sgqlc.types + +import datahub.ingestion.source.tableau.codegen_sgqlc.tableau_schema as tableau_schema + +_schema = tableau_schema +_schema_root = _schema.tableau_schema + +__all__ = ("Operations",) + + +def query_get_items_database_tables_connection(): + _op = sgqlc.operation.Operation( + _schema_root.query_type, + name="GetItems_databaseTablesConnection", + variables=dict( + first=sgqlc.types.Arg(_schema.Int), after=sgqlc.types.Arg(_schema.String) + ), + ) + _op_database_tables_connection = _op.database_tables_connection( + first=sgqlc.types.Variable("first"), + after=sgqlc.types.Variable("after"), + filter={ + "idWithin": ( + "76e2151b-124f-7ec8-896b-dd107eafca05", + "a1b165ad-c7c2-282d-94c5-1b8a877936ee", + "2d3bdb4e-08da-a6da-fecb-a3c10abba357", + "92b0a3ae-2fc9-1b42-47e0-c17d0f0b615a", + "63ffbbfe-8c2d-c4f3-7a28-e11f247227c7", + "06d776e1-9376-bc06-84d5-c7a5c4253bf5", + "159ed86e-796f-3f13-8f07-3e63c271015e", + "2f2ccb48-edd5-0e02-4d51-eb3b0819fbf1", + "2fe499f7-9c5a-81ef-f32d-9553dcc86044", + "4a34ada9-ed4a-089f-01d0-4a1f230ee2e6", + ) + }, + ) + _op_database_tables_connection_nodes = _op_database_tables_connection.nodes() + _op_database_tables_connection_nodes.id() + _op_database_tables_connection_nodes.is_embedded() + _op_database_tables_connection_nodes_columns = ( + _op_database_tables_connection_nodes.columns() + ) + _op_database_tables_connection_nodes_columns.remote_type() + _op_database_tables_connection_nodes_columns.name() + _op_database_tables_connection_page_info = ( + _op_database_tables_connection.page_info() + ) + _op_database_tables_connection_page_info.has_next_page() + _op_database_tables_connection_page_info.end_cursor() + return _op + + +def query_get_items_custom_sqltables_connection(): + _op = sgqlc.operation.Operation( + _schema_root.query_type, + name="GetItems_customSQLTablesConnection", + variables=dict( + first=sgqlc.types.Arg(_schema.Int), after=sgqlc.types.Arg(_schema.String) + ), + ) + _op_custom_sqltables_connection = _op.custom_sqltables_connection( + first=sgqlc.types.Variable("first"), + after=sgqlc.types.Variable("after"), + filter={ + "idWithin": ( + "81335c49-5edc-bbfa-77c9-c4a1cd444501", + "48c19c5f-4300-07bb-17ee-1fbdf6824ff6", + ) + }, + ) + _op_custom_sqltables_connection_nodes = _op_custom_sqltables_connection.nodes() + _op_custom_sqltables_connection_nodes.id() + _op_custom_sqltables_connection_nodes.name() + _op_custom_sqltables_connection_nodes.query() + _op_custom_sqltables_connection_nodes_columns = ( + _op_custom_sqltables_connection_nodes.columns() + ) + _op_custom_sqltables_connection_nodes_columns.id() + _op_custom_sqltables_connection_nodes_columns.name() + _op_custom_sqltables_connection_nodes_columns.remote_type() + _op_custom_sqltables_connection_nodes_columns.description() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields = ( + _op_custom_sqltables_connection_nodes_columns.referenced_by_fields() + ) + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource = ( + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields.datasource() + ) + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource.__typename__() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource.id() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource.name() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource_upstream_tables = _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource.upstream_tables() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource_upstream_tables.id() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource_upstream_tables.name() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource_upstream_tables_database = _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource_upstream_tables.database() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource_upstream_tables_database.name() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource_upstream_tables_database.id() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource_upstream_tables.schema() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource_upstream_tables.full_name() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource_upstream_tables.connection_type() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource__as__PublishedDatasource = _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource.__as__( + _schema.PublishedDatasource + ) + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource__as__PublishedDatasource.project_name() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource__as__PublishedDatasource.luid() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource__as__EmbeddedDatasource = _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource.__as__( + _schema.EmbeddedDatasource + ) + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource__as__EmbeddedDatasource_workbook = _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource__as__EmbeddedDatasource.workbook() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource__as__EmbeddedDatasource_workbook.id() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource__as__EmbeddedDatasource_workbook.name() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource__as__EmbeddedDatasource_workbook.project_name() + _op_custom_sqltables_connection_nodes_columns_referenced_by_fields_datasource__as__EmbeddedDatasource_workbook.luid() + _op_custom_sqltables_connection_nodes_tables = ( + _op_custom_sqltables_connection_nodes.tables() + ) + _op_custom_sqltables_connection_nodes_tables.id() + _op_custom_sqltables_connection_nodes_tables.name() + _op_custom_sqltables_connection_nodes_tables_database = ( + _op_custom_sqltables_connection_nodes_tables.database() + ) + _op_custom_sqltables_connection_nodes_tables_database.name() + _op_custom_sqltables_connection_nodes_tables_database.id() + _op_custom_sqltables_connection_nodes_tables.schema() + _op_custom_sqltables_connection_nodes_tables.full_name() + _op_custom_sqltables_connection_nodes_tables.connection_type() + _op_custom_sqltables_connection_nodes_tables.description() + _op_custom_sqltables_connection_nodes_tables_columns_connection = ( + _op_custom_sqltables_connection_nodes_tables.columns_connection() + ) + _op_custom_sqltables_connection_nodes_tables_columns_connection.total_count() + _op_custom_sqltables_connection_nodes.connection_type() + _op_custom_sqltables_connection_nodes_database = ( + _op_custom_sqltables_connection_nodes.database() + ) + _op_custom_sqltables_connection_nodes_database.name() + _op_custom_sqltables_connection_nodes_database.id() + _op_custom_sqltables_connection_nodes_database.connection_type() + _op_custom_sqltables_connection_page_info = ( + _op_custom_sqltables_connection.page_info() + ) + _op_custom_sqltables_connection_page_info.has_next_page() + _op_custom_sqltables_connection_page_info.end_cursor() + return _op + + +def query_get_items_published_datasources_connection(): + _op = sgqlc.operation.Operation( + _schema_root.query_type, + name="GetItems_publishedDatasourcesConnection", + variables=dict( + first=sgqlc.types.Arg(_schema.Int), after=sgqlc.types.Arg(_schema.String) + ), + ) + _op_published_datasources_connection = _op.published_datasources_connection( + first=sgqlc.types.Variable("first"), + after=sgqlc.types.Variable("after"), + filter={ + "idWithin": ( + "35d62018-68e1-6ad4-2cf0-d3ede4ee9a67", + "87d9d9d8-59a8-adc3-3e06-f75c5b98ec52", + "ae8b52c9-1481-06fd-fe96-e6d4938f9fcb", + ) + }, + ) + _op_published_datasources_connection_nodes = ( + _op_published_datasources_connection.nodes() + ) + _op_published_datasources_connection_nodes.__typename__() + _op_published_datasources_connection_nodes.id() + _op_published_datasources_connection_nodes.name() + _op_published_datasources_connection_nodes.luid() + _op_published_datasources_connection_nodes.has_extracts() + _op_published_datasources_connection_nodes.extract_last_refresh_time() + _op_published_datasources_connection_nodes.extract_last_incremental_update_time() + _op_published_datasources_connection_nodes.extract_last_update_time() + _op_published_datasources_connection_nodes_upstream_tables = ( + _op_published_datasources_connection_nodes.upstream_tables() + ) + _op_published_datasources_connection_nodes_upstream_tables.id() + _op_published_datasources_connection_nodes_upstream_tables.name() + _op_published_datasources_connection_nodes_upstream_tables_database = ( + _op_published_datasources_connection_nodes_upstream_tables.database() + ) + _op_published_datasources_connection_nodes_upstream_tables_database.name() + _op_published_datasources_connection_nodes_upstream_tables_database.id() + _op_published_datasources_connection_nodes_upstream_tables.schema() + _op_published_datasources_connection_nodes_upstream_tables.full_name() + _op_published_datasources_connection_nodes_upstream_tables.connection_type() + _op_published_datasources_connection_nodes_upstream_tables.description() + _op_published_datasources_connection_nodes_upstream_tables_columns_connection = ( + _op_published_datasources_connection_nodes_upstream_tables.columns_connection() + ) + _op_published_datasources_connection_nodes_upstream_tables_columns_connection.total_count() + _op_published_datasources_connection_nodes_fields = ( + _op_published_datasources_connection_nodes.fields() + ) + _op_published_datasources_connection_nodes_fields.__typename__() + _op_published_datasources_connection_nodes_fields.id() + _op_published_datasources_connection_nodes_fields.name() + _op_published_datasources_connection_nodes_fields.description() + _op_published_datasources_connection_nodes_fields.is_hidden() + _op_published_datasources_connection_nodes_fields.folder_name() + _op_published_datasources_connection_nodes_fields__as__ColumnField = ( + _op_published_datasources_connection_nodes_fields.__as__(_schema.ColumnField) + ) + _op_published_datasources_connection_nodes_fields__as__ColumnField.data_category() + _op_published_datasources_connection_nodes_fields__as__ColumnField.role() + _op_published_datasources_connection_nodes_fields__as__ColumnField.data_type() + _op_published_datasources_connection_nodes_fields__as__ColumnField.default_format() + _op_published_datasources_connection_nodes_fields__as__ColumnField.aggregation() + _op_published_datasources_connection_nodes_fields__as__CalculatedField = ( + _op_published_datasources_connection_nodes_fields.__as__( + _schema.CalculatedField + ) + ) + _op_published_datasources_connection_nodes_fields__as__CalculatedField.role() + _op_published_datasources_connection_nodes_fields__as__CalculatedField.data_type() + _op_published_datasources_connection_nodes_fields__as__CalculatedField.default_format() + _op_published_datasources_connection_nodes_fields__as__CalculatedField.aggregation() + _op_published_datasources_connection_nodes_fields__as__CalculatedField.formula() + _op_published_datasources_connection_nodes_fields__as__GroupField = ( + _op_published_datasources_connection_nodes_fields.__as__(_schema.GroupField) + ) + _op_published_datasources_connection_nodes_fields__as__GroupField.role() + _op_published_datasources_connection_nodes_fields__as__GroupField.data_type() + _op_published_datasources_connection_nodes_owner = ( + _op_published_datasources_connection_nodes.owner() + ) + _op_published_datasources_connection_nodes_owner.username() + _op_published_datasources_connection_nodes.description() + _op_published_datasources_connection_nodes.uri() + _op_published_datasources_connection_nodes.project_name() + _op_published_datasources_connection_nodes_tags = ( + _op_published_datasources_connection_nodes.tags() + ) + _op_published_datasources_connection_nodes_tags.name() + _op_published_datasources_connection_page_info = ( + _op_published_datasources_connection.page_info() + ) + _op_published_datasources_connection_page_info.has_next_page() + _op_published_datasources_connection_page_info.end_cursor() + return _op + + +def query_get_items_fields_connection(): + _op = sgqlc.operation.Operation( + _schema_root.query_type, + name="GetItems_fieldsConnection", + variables=dict( + first=sgqlc.types.Arg(_schema.Int), after=sgqlc.types.Arg(_schema.String) + ), + ) + _op_fields_connection = _op.fields_connection( + first=sgqlc.types.Variable("first"), + after=sgqlc.types.Variable("after"), + filter={ + "idWithin": ( + "668470bc-f0c9-ec5d-7a4b-172370d6ef45", + "66bd48ba-a895-4951-a4e1-d26fc191eae9", + "672a63ee-c34b-8cb4-506b-163fcb131a52", + "72684adf-d214-0a9a-946c-dd7b3879b51f", + "76636a30-dfbf-0107-0190-a0fc6ce201be", + "77aa21d6-3b79-0be0-d309-3d36ef1efe71", + "8fbf178a-ceef-2c97-3ac8-26f95a004d67", + "968608d1-5da4-1a97-e96a-269010d4ef5b", + "b5ae252a-c3c0-3a2d-c147-7a39a8de59ef", + "bc1641b9-525d-00c5-f163-02519d46f0fd", + ) + }, + ) + _op_fields_connection_nodes = _op_fields_connection.nodes() + _op_fields_connection_nodes.id() + _op_fields_connection_nodes_upstream_fields = ( + _op_fields_connection_nodes.upstream_fields() + ) + _op_fields_connection_nodes_upstream_fields.name() + _op_fields_connection_nodes_upstream_fields_datasource = ( + _op_fields_connection_nodes_upstream_fields.datasource() + ) + _op_fields_connection_nodes_upstream_fields_datasource.id() + _op_fields_connection_nodes_upstream_columns = ( + _op_fields_connection_nodes.upstream_columns() + ) + _op_fields_connection_nodes_upstream_columns.name() + _op_fields_connection_nodes_upstream_columns_table = ( + _op_fields_connection_nodes_upstream_columns.table() + ) + _op_fields_connection_nodes_upstream_columns_table.__typename__() + _op_fields_connection_nodes_upstream_columns_table.id() + _op_fields_connection_page_info = _op_fields_connection.page_info() + _op_fields_connection_page_info.has_next_page() + _op_fields_connection_page_info.end_cursor() + return _op + + +def query_get_items_embedded_datasources_connection(): + _op = sgqlc.operation.Operation( + _schema_root.query_type, + name="GetItems_embeddedDatasourcesConnection", + variables=dict( + first=sgqlc.types.Arg(_schema.Int), after=sgqlc.types.Arg(_schema.String) + ), + ) + _op_embedded_datasources_connection = _op.embedded_datasources_connection( + first=sgqlc.types.Variable("first"), + after=sgqlc.types.Variable("after"), + filter={ + "idWithin": ( + "7437c561-4e94-0283-3462-c6205c2288cd", + "797a69b1-c32a-2fd4-62aa-99989c1858a6", + "79871b17-d526-17be-df59-e001f7140924", + "8f5e3006-6756-8eea-4fd3-44781cea1493", + "1c5653d6-c448-0850-108b-5c78aeaf6b51", + "6731f648-b756-31ea-fcdd-77309dd3b0c3", + "6bd53e72-9fe4-ea86-3d23-14b826c13fa5", + "3f46592d-f789-8f48-466e-69606990d589", + "415ddd3e-be04-b466-bc7c-5678a4b0a733", + "e9b47a00-12ff-72cc-9dfb-d34e0c65095d", + ) + }, + ) + _op_embedded_datasources_connection_nodes = ( + _op_embedded_datasources_connection.nodes() + ) + _op_embedded_datasources_connection_nodes.__typename__() + _op_embedded_datasources_connection_nodes.id() + _op_embedded_datasources_connection_nodes.name() + _op_embedded_datasources_connection_nodes.has_extracts() + _op_embedded_datasources_connection_nodes.extract_last_refresh_time() + _op_embedded_datasources_connection_nodes.extract_last_incremental_update_time() + _op_embedded_datasources_connection_nodes.extract_last_update_time() + _op_embedded_datasources_connection_nodes_downstream_sheets = ( + _op_embedded_datasources_connection_nodes.downstream_sheets() + ) + _op_embedded_datasources_connection_nodes_downstream_sheets.name() + _op_embedded_datasources_connection_nodes_downstream_sheets.id() + _op_embedded_datasources_connection_nodes_upstream_tables = ( + _op_embedded_datasources_connection_nodes.upstream_tables() + ) + _op_embedded_datasources_connection_nodes_upstream_tables.id() + _op_embedded_datasources_connection_nodes_upstream_tables.name() + _op_embedded_datasources_connection_nodes_upstream_tables_database = ( + _op_embedded_datasources_connection_nodes_upstream_tables.database() + ) + _op_embedded_datasources_connection_nodes_upstream_tables_database.name() + _op_embedded_datasources_connection_nodes_upstream_tables_database.id() + _op_embedded_datasources_connection_nodes_upstream_tables.schema() + _op_embedded_datasources_connection_nodes_upstream_tables.full_name() + _op_embedded_datasources_connection_nodes_upstream_tables.connection_type() + _op_embedded_datasources_connection_nodes_upstream_tables.description() + _op_embedded_datasources_connection_nodes_upstream_tables_columns_connection = ( + _op_embedded_datasources_connection_nodes_upstream_tables.columns_connection() + ) + _op_embedded_datasources_connection_nodes_upstream_tables_columns_connection.total_count() + _op_embedded_datasources_connection_nodes_fields = ( + _op_embedded_datasources_connection_nodes.fields() + ) + _op_embedded_datasources_connection_nodes_fields.__typename__() + _op_embedded_datasources_connection_nodes_fields.id() + _op_embedded_datasources_connection_nodes_fields.name() + _op_embedded_datasources_connection_nodes_fields.description() + _op_embedded_datasources_connection_nodes_fields.is_hidden() + _op_embedded_datasources_connection_nodes_fields.folder_name() + _op_embedded_datasources_connection_nodes_fields__as__ColumnField = ( + _op_embedded_datasources_connection_nodes_fields.__as__(_schema.ColumnField) + ) + _op_embedded_datasources_connection_nodes_fields__as__ColumnField.data_category() + _op_embedded_datasources_connection_nodes_fields__as__ColumnField.role() + _op_embedded_datasources_connection_nodes_fields__as__ColumnField.data_type() + _op_embedded_datasources_connection_nodes_fields__as__ColumnField.default_format() + _op_embedded_datasources_connection_nodes_fields__as__ColumnField.aggregation() + _op_embedded_datasources_connection_nodes_fields__as__CalculatedField = ( + _op_embedded_datasources_connection_nodes_fields.__as__(_schema.CalculatedField) + ) + _op_embedded_datasources_connection_nodes_fields__as__CalculatedField.role() + _op_embedded_datasources_connection_nodes_fields__as__CalculatedField.data_type() + _op_embedded_datasources_connection_nodes_fields__as__CalculatedField.default_format() + _op_embedded_datasources_connection_nodes_fields__as__CalculatedField.aggregation() + _op_embedded_datasources_connection_nodes_fields__as__CalculatedField.formula() + _op_embedded_datasources_connection_nodes_fields__as__GroupField = ( + _op_embedded_datasources_connection_nodes_fields.__as__(_schema.GroupField) + ) + _op_embedded_datasources_connection_nodes_fields__as__GroupField.role() + _op_embedded_datasources_connection_nodes_fields__as__GroupField.data_type() + _op_embedded_datasources_connection_nodes_upstream_datasources = ( + _op_embedded_datasources_connection_nodes.upstream_datasources() + ) + _op_embedded_datasources_connection_nodes_upstream_datasources.id() + _op_embedded_datasources_connection_nodes_upstream_datasources.name() + _op_embedded_datasources_connection_nodes_workbook = ( + _op_embedded_datasources_connection_nodes.workbook() + ) + _op_embedded_datasources_connection_nodes_workbook.id() + _op_embedded_datasources_connection_nodes_workbook.name() + _op_embedded_datasources_connection_nodes_workbook.project_name() + _op_embedded_datasources_connection_nodes_workbook.luid() + _op_embedded_datasources_connection_nodes_workbook_owner = ( + _op_embedded_datasources_connection_nodes_workbook.owner() + ) + _op_embedded_datasources_connection_nodes_workbook_owner.username() + _op_embedded_datasources_connection_page_info = ( + _op_embedded_datasources_connection.page_info() + ) + _op_embedded_datasources_connection_page_info.has_next_page() + _op_embedded_datasources_connection_page_info.end_cursor() + return _op + + +def query_get_items_sheets_connection(): + _op = sgqlc.operation.Operation( + _schema_root.query_type, + name="GetItems_sheetsConnection", + variables=dict( + first=sgqlc.types.Arg(_schema.Int), after=sgqlc.types.Arg(_schema.String) + ), + ) + _op_sheets_connection = _op.sheets_connection( + first=sgqlc.types.Variable("first"), + after=sgqlc.types.Variable("after"), + filter={ + "idWithin": ( + "fa9e30e8-645e-1105-642d-c292c70a921c", + "cea027c2-24a2-d009-4ccf-ac172a3fac6e", + "b4f94b9f-26dc-3fb3-1973-796e4c91cb21", + "f6682a87-7396-f12e-2fd1-0424157c6ceb", + "8fb398c1-0b18-528a-c3bd-2a03c35528f5", + "ffe3435f-3e0b-9618-389c-055cbed13ac9", + "4e51108f-3ba4-0749-6518-8104fc62c202", + "67f86c94-c102-447a-8752-b1e497bf4551", + "cbb0b196-5f2a-ecd4-0b2b-e87db220ff47", + "1359177d-c634-2cff-4408-1751152c7fc2", + ) + }, + ) + _op_sheets_connection_nodes = _op_sheets_connection.nodes() + _op_sheets_connection_nodes.id() + _op_sheets_connection_nodes.name() + _op_sheets_connection_nodes.path() + _op_sheets_connection_nodes.luid() + _op_sheets_connection_nodes.created_at() + _op_sheets_connection_nodes.updated_at() + _op_sheets_connection_nodes_tags = _op_sheets_connection_nodes.tags() + _op_sheets_connection_nodes_tags.name() + _op_sheets_connection_nodes_contained_in_dashboards = ( + _op_sheets_connection_nodes.contained_in_dashboards() + ) + _op_sheets_connection_nodes_contained_in_dashboards.name() + _op_sheets_connection_nodes_contained_in_dashboards.path() + _op_sheets_connection_nodes_workbook = _op_sheets_connection_nodes.workbook() + _op_sheets_connection_nodes_workbook.id() + _op_sheets_connection_nodes_workbook.name() + _op_sheets_connection_nodes_workbook.project_name() + _op_sheets_connection_nodes_workbook.luid() + _op_sheets_connection_nodes_workbook_owner = ( + _op_sheets_connection_nodes_workbook.owner() + ) + _op_sheets_connection_nodes_workbook_owner.username() + _op_sheets_connection_nodes_datasource_fields = ( + _op_sheets_connection_nodes.datasource_fields() + ) + _op_sheets_connection_nodes_datasource_fields.__typename__() + _op_sheets_connection_nodes_datasource_fields.id() + _op_sheets_connection_nodes_datasource_fields.name() + _op_sheets_connection_nodes_datasource_fields.description() + _op_sheets_connection_nodes_datasource_fields_datasource = ( + _op_sheets_connection_nodes_datasource_fields.datasource() + ) + _op_sheets_connection_nodes_datasource_fields_datasource.id() + _op_sheets_connection_nodes_datasource_fields_datasource.name() + _op_sheets_connection_nodes_datasource_fields__as__ColumnField = ( + _op_sheets_connection_nodes_datasource_fields.__as__(_schema.ColumnField) + ) + _op_sheets_connection_nodes_datasource_fields__as__ColumnField.data_category() + _op_sheets_connection_nodes_datasource_fields__as__ColumnField.role() + _op_sheets_connection_nodes_datasource_fields__as__ColumnField.data_type() + _op_sheets_connection_nodes_datasource_fields__as__ColumnField.aggregation() + _op_sheets_connection_nodes_datasource_fields__as__CalculatedField = ( + _op_sheets_connection_nodes_datasource_fields.__as__(_schema.CalculatedField) + ) + _op_sheets_connection_nodes_datasource_fields__as__CalculatedField.role() + _op_sheets_connection_nodes_datasource_fields__as__CalculatedField.data_type() + _op_sheets_connection_nodes_datasource_fields__as__CalculatedField.aggregation() + _op_sheets_connection_nodes_datasource_fields__as__CalculatedField.formula() + _op_sheets_connection_nodes_datasource_fields__as__GroupField = ( + _op_sheets_connection_nodes_datasource_fields.__as__(_schema.GroupField) + ) + _op_sheets_connection_nodes_datasource_fields__as__GroupField.role() + _op_sheets_connection_nodes_datasource_fields__as__GroupField.data_type() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField = ( + _op_sheets_connection_nodes_datasource_fields.__as__(_schema.DatasourceField) + ) + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field = _op_sheets_connection_nodes_datasource_fields__as__DatasourceField.remote_field() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field.__typename__() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field.id() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field.name() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field.description() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field.folder_name() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__ColumnField = _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field.__as__( + _schema.ColumnField + ) + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__ColumnField.data_category() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__ColumnField.role() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__ColumnField.data_type() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__ColumnField.aggregation() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__CalculatedField = _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field.__as__( + _schema.CalculatedField + ) + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__CalculatedField.role() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__CalculatedField.data_type() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__CalculatedField.aggregation() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__CalculatedField.formula() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__GroupField = _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field.__as__( + _schema.GroupField + ) + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__GroupField.role() + _op_sheets_connection_nodes_datasource_fields__as__DatasourceField_remote_field__as__GroupField.data_type() + _op_sheets_connection_page_info = _op_sheets_connection.page_info() + _op_sheets_connection_page_info.has_next_page() + _op_sheets_connection_page_info.end_cursor() + return _op + + +def query_get_items_workbooks_connection(): + _op = sgqlc.operation.Operation( + _schema_root.query_type, + name="GetItems_workbooksConnection", + variables=dict( + first=sgqlc.types.Arg(_schema.Int), after=sgqlc.types.Arg(_schema.String) + ), + ) + _op_workbooks_connection = _op.workbooks_connection( + first=sgqlc.types.Variable("first"), + after=sgqlc.types.Variable("after"), + filter={"projectNameWithin": ("project_test2",)}, + ) + _op_workbooks_connection_nodes = _op_workbooks_connection.nodes() + _op_workbooks_connection_nodes.id() + _op_workbooks_connection_nodes.name() + _op_workbooks_connection_nodes.luid() + _op_workbooks_connection_nodes.uri() + _op_workbooks_connection_nodes.project_name() + _op_workbooks_connection_nodes_owner = _op_workbooks_connection_nodes.owner() + _op_workbooks_connection_nodes_owner.username() + _op_workbooks_connection_nodes.description() + _op_workbooks_connection_nodes.uri() + _op_workbooks_connection_nodes.created_at() + _op_workbooks_connection_nodes.updated_at() + _op_workbooks_connection_nodes_tags = _op_workbooks_connection_nodes.tags() + _op_workbooks_connection_nodes_tags.name() + _op_workbooks_connection_nodes_sheets = _op_workbooks_connection_nodes.sheets() + _op_workbooks_connection_nodes_sheets.id() + _op_workbooks_connection_nodes_dashboards = ( + _op_workbooks_connection_nodes.dashboards() + ) + _op_workbooks_connection_nodes_dashboards.id() + _op_workbooks_connection_nodes_embedded_datasources = ( + _op_workbooks_connection_nodes.embedded_datasources() + ) + _op_workbooks_connection_nodes_embedded_datasources.id() + _op_workbooks_connection_page_info = _op_workbooks_connection.page_info() + _op_workbooks_connection_page_info.has_next_page() + _op_workbooks_connection_page_info.end_cursor() + return _op + + +class Query: + get_items_custom_sqltables_connection = ( + query_get_items_custom_sqltables_connection() + ) + get_items_database_tables_connection = query_get_items_database_tables_connection() + get_items_embedded_datasources_connection = ( + query_get_items_embedded_datasources_connection() + ) + get_items_fields_connection = query_get_items_fields_connection() + get_items_published_datasources_connection = ( + query_get_items_published_datasources_connection() + ) + get_items_sheets_connection = query_get_items_sheets_connection() + get_items_workbooks_connection = query_get_items_workbooks_connection() + + +class Operations: + query = Query diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py new file mode 100644 index 0000000000000..1e4facd7fbbc0 --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py @@ -0,0 +1,54071 @@ +import sgqlc.types +import sgqlc.types.datetime +import sgqlc.types.relay + +tableau_schema = sgqlc.types.Schema() + + +# Unexport Node/PageInfo, let schema re-declare them +tableau_schema -= sgqlc.types.relay.Node +tableau_schema -= sgqlc.types.relay.PageInfo + + +__docformat__ = "markdown" + + +######################################################################## +# Scalars and Enumerations +######################################################################## +class AnalyticsFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + """ + + __schema__ = tableau_schema + __choices__ = ("ID",) + + +class AskDataExtensionOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + """ + + __schema__ = tableau_schema + __choices__ = ("ID",) + + +class BinFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DATA_CATEGORY`: Sort by dataCategory + * `DATA_TYPE`: Sort by dataType + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `IS_HIDDEN`: Sort by isHidden + * `NAME`: Sort by name + * `ROLE`: Sort by role + """ + + __schema__ = tableau_schema + __choices__ = ( + "DATA_CATEGORY", + "DATA_TYPE", + "DOWNSTREAM_SHEETS_COUNT", + "FIELDS_COUNT", + "ID", + "IS_HIDDEN", + "NAME", + "ROLE", + ) + + +Boolean = sgqlc.types.Boolean + + +class CalculatedFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DATA_CATEGORY`: Sort by dataCategory + * `DATA_TYPE`: Sort by dataType + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `IS_HIDDEN`: Sort by isHidden + * `NAME`: Sort by name + * `ROLE`: Sort by role + """ + + __schema__ = tableau_schema + __choices__ = ( + "DATA_CATEGORY", + "DATA_TYPE", + "DOWNSTREAM_SHEETS_COUNT", + "FIELDS_COUNT", + "ID", + "IS_HIDDEN", + "NAME", + "ROLE", + ) + + +class CanHaveLabelsOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `LUID`: Sort by luid + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "LUID") + + +class CertifiableOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `LUID`: Sort by luid + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "IS_CERTIFIED", "LUID") + + +class CloudFileOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONNECTION_TYPE`: Sort by connectionType + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT`: Sort by + downstreamVirtualConnections count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `IS_EMBEDDED`: Sort by isEmbedded + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PROJECT_NAME`: Sort by projectName + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONNECTION_TYPE", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "HAS_ACTIVE_WARNING", + "ID", + "IS_CERTIFIED", + "IS_EMBEDDED", + "LUID", + "NAME", + "PROJECT_NAME", + ) + + +class ColumnFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DATA_CATEGORY`: Sort by dataCategory + * `DATA_TYPE`: Sort by dataType + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `ID`: Sort by id + * `IS_HIDDEN`: Sort by isHidden + * `NAME`: Sort by name + * `ROLE`: Sort by role + """ + + __schema__ = tableau_schema + __choices__ = ( + "DATA_CATEGORY", + "DATA_TYPE", + "DOWNSTREAM_SHEETS_COUNT", + "ID", + "IS_HIDDEN", + "NAME", + "ROLE", + ) + + +class ColumnOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DISPLAY_NAME`: Sort by displayName + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ( + "DISPLAY_NAME", + "DOWNSTREAM_SHEETS_COUNT", + "HAS_ACTIVE_WARNING", + "ID", + "LUID", + "NAME", + ) + + +class CombinedFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `IS_HIDDEN`: Sort by isHidden + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("DOWNSTREAM_SHEETS_COUNT", "FIELDS_COUNT", "ID", "IS_HIDDEN", "NAME") + + +class CombinedSetFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `IS_HIDDEN`: Sort by isHidden + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("DOWNSTREAM_SHEETS_COUNT", "FIELDS_COUNT", "ID", "IS_HIDDEN", "NAME") + + +class CustomSQLTableOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `COLUMNS_COUNT`: Sort by columns count + * `DOWNSTREAM_DASHBOARDS_COUNT`: Sort by downstreamDashboards + count + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `ID`: Sort by id + * `IS_UNSUPPORTED_CUSTOM_SQL`: Sort by isUnsupportedCustomSql + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ( + "COLUMNS_COUNT", + "DOWNSTREAM_DASHBOARDS_COUNT", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "ID", + "IS_UNSUPPORTED_CUSTOM_SQL", + "NAME", + ) + + +class DashboardOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DOCUMENT_VIEW_ID`: Sort by documentViewId + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PATH`: Sort by path + """ + + __schema__ = tableau_schema + __choices__ = ("DOCUMENT_VIEW_ID", "ID", "LUID", "NAME", "PATH") + + +class DataCloudOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONNECTION_TYPE`: Sort by connectionType + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT`: Sort by + downstreamVirtualConnections count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `IS_EMBEDDED`: Sort by isEmbedded + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PROJECT_NAME`: Sort by projectName + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONNECTION_TYPE", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "HAS_ACTIVE_WARNING", + "ID", + "IS_CERTIFIED", + "IS_EMBEDDED", + "LUID", + "NAME", + "PROJECT_NAME", + ) + + +class DataFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DATA_CATEGORY`: Sort by dataCategory + * `DATA_TYPE`: Sort by dataType + * `ID`: Sort by id + * `ROLE`: Sort by role + """ + + __schema__ = tableau_schema + __choices__ = ("DATA_CATEGORY", "DATA_TYPE", "ID", "ROLE") + + +class DataQualityCertificationOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CATEGORY`: Sort by category + * `ID`: Sort by id + * `IS_ACTIVE`: Sort by isActive + * `IS_ELEVATED`: Sort by isElevated + * `LUID`: Sort by luid + * `VALUE`: Sort by value + """ + + __schema__ = tableau_schema + __choices__ = ("CATEGORY", "ID", "IS_ACTIVE", "IS_ELEVATED", "LUID", "VALUE") + + +class DataQualityWarningOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CATEGORY`: Sort by category + * `ID`: Sort by id + * `IS_ACTIVE`: Sort by isActive + * `IS_ELEVATED`: Sort by isElevated + * `IS_SEVERE`: Sort by isSevere + * `LUID`: Sort by luid + * `VALUE`: Sort by value + * `WARNING_TYPE`: Sort by warningType + """ + + __schema__ = tableau_schema + __choices__ = ( + "CATEGORY", + "ID", + "IS_ACTIVE", + "IS_ELEVATED", + "IS_SEVERE", + "LUID", + "VALUE", + "WARNING_TYPE", + ) + + +class DatabaseOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONNECTION_TYPE`: Sort by connectionType + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT`: Sort by + downstreamVirtualConnections count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `IS_EMBEDDED`: Sort by isEmbedded + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PROJECT_NAME`: Sort by projectName + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONNECTION_TYPE", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "HAS_ACTIVE_WARNING", + "ID", + "IS_CERTIFIED", + "IS_EMBEDDED", + "LUID", + "NAME", + "PROJECT_NAME", + ) + + +class DatabaseServerOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONNECTION_TYPE`: Sort by connectionType + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT`: Sort by + downstreamVirtualConnections count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `HOST_NAME`: Sort by hostName + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `IS_EMBEDDED`: Sort by isEmbedded + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PROJECT_NAME`: Sort by projectName + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONNECTION_TYPE", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "HAS_ACTIVE_WARNING", + "HOST_NAME", + "ID", + "IS_CERTIFIED", + "IS_EMBEDDED", + "LUID", + "NAME", + "PROJECT_NAME", + ) + + +class DatabaseTableOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `COLUMNS_COUNT`: Sort by columns count + * `CONNECTION_TYPE`: Sort by connectionType + * `DOWNSTREAM_DASHBOARDS_COUNT`: Sort by downstreamDashboards + count + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT`: Sort by + downstreamVirtualConnections count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `FULL_NAME`: Sort by fullName + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `IS_EMBEDDED`: Sort by isEmbedded + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PROJECT_NAME`: Sort by projectName + * `SCHEMA`: Sort by schema + """ + + __schema__ = tableau_schema + __choices__ = ( + "COLUMNS_COUNT", + "CONNECTION_TYPE", + "DOWNSTREAM_DASHBOARDS_COUNT", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "FULL_NAME", + "HAS_ACTIVE_WARNING", + "ID", + "IS_CERTIFIED", + "IS_EMBEDDED", + "LUID", + "NAME", + "PROJECT_NAME", + "SCHEMA", + ) + + +class DatasourceFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `ID`: Sort by id + * `IS_HIDDEN`: Sort by isHidden + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("DOWNSTREAM_SHEETS_COUNT", "ID", "IS_HIDDEN", "NAME") + + +class DatasourceFilterOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + """ + + __schema__ = tableau_schema + __choices__ = ("ID",) + + +class DatasourceOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONTAINS_UNSUPPORTED_CUSTOM_SQL`: Sort by + containsUnsupportedCustomSql + * `DOWNSTREAM_OWNERS_COUNT`: Sort by downstreamOwners count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONTAINS_UNSUPPORTED_CUSTOM_SQL", + "DOWNSTREAM_OWNERS_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "FIELDS_COUNT", + "ID", + "NAME", + ) + + +DateTime = sgqlc.types.datetime.DateTime + + +class EmbeddedDatasourceOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONTAINS_UNSUPPORTED_CUSTOM_SQL`: Sort by + containsUnsupportedCustomSql + * `DOWNSTREAM_OWNERS_COUNT`: Sort by downstreamOwners count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONTAINS_UNSUPPORTED_CUSTOM_SQL", + "DOWNSTREAM_OWNERS_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "FIELDS_COUNT", + "ID", + "NAME", + ) + + +class ExtractType(sgqlc.types.Enum): + """Possible types of extract + + Enumeration Choices: + + * `FULL`None + * `INCREMENTAL`None + """ + + __schema__ = tableau_schema + __choices__ = ("FULL", "INCREMENTAL") + + +class FieldDataType(sgqlc.types.Enum): + """Possible data types for a field. + + Enumeration Choices: + + * `BOOLEAN`None + * `DATE`None + * `DATETIME`None + * `INTEGER`None + * `REAL`None + * `SPATIAL`None + * `STRING`None + * `TABLE`None + * `TUPLE`None + * `UNKNOWN`None + """ + + __schema__ = tableau_schema + __choices__ = ( + "BOOLEAN", + "DATE", + "DATETIME", + "INTEGER", + "REAL", + "SPATIAL", + "STRING", + "TABLE", + "TUPLE", + "UNKNOWN", + ) + + +class FieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `ID`: Sort by id + * `IS_HIDDEN`: Sort by isHidden + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("DOWNSTREAM_SHEETS_COUNT", "ID", "IS_HIDDEN", "NAME") + + +class FieldReferencingFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + """ + + __schema__ = tableau_schema + __choices__ = ("FIELDS_COUNT", "ID") + + +class FieldRole(sgqlc.types.Enum): + """Possible roles of a field. + + Enumeration Choices: + + * `DIMENSION`None + * `MEASURE`None + * `UNKNOWN`None + """ + + __schema__ = tableau_schema + __choices__ = ("DIMENSION", "MEASURE", "UNKNOWN") + + +class FieldRoleCategory(sgqlc.types.Enum): + """Possible categories of a field role. + + Enumeration Choices: + + * `NOMINAL`None + * `ORDINAL`None + * `QUANTITATIVE`None + * `UNKNOWN`None + """ + + __schema__ = tableau_schema + __choices__ = ("NOMINAL", "ORDINAL", "QUANTITATIVE", "UNKNOWN") + + +class FileOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONNECTION_TYPE`: Sort by connectionType + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT`: Sort by + downstreamVirtualConnections count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `IS_EMBEDDED`: Sort by isEmbedded + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PROJECT_NAME`: Sort by projectName + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONNECTION_TYPE", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "HAS_ACTIVE_WARNING", + "ID", + "IS_CERTIFIED", + "IS_EMBEDDED", + "LUID", + "NAME", + "PROJECT_NAME", + ) + + +class FlowColumnInputFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "NAME") + + +class FlowColumnOutputFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "NAME") + + +class FlowFieldInputFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "NAME") + + +class FlowFieldOutputFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "NAME") + + +class FlowInputFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "NAME") + + +class FlowOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONTAINER_NAME`: Sort by containerName + * `CONTAINS_UNSUPPORTED_CUSTOM_SQL`: Sort by + containsUnsupportedCustomSql + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PROJECT_NAME`: Sort by projectName + * `VIZPORTAL_URL_ID`: Sort by vizportalUrlId + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONTAINER_NAME", + "CONTAINS_UNSUPPORTED_CUSTOM_SQL", + "HAS_ACTIVE_WARNING", + "ID", + "LUID", + "NAME", + "PROJECT_NAME", + "VIZPORTAL_URL_ID", + ) + + +class FlowOutputFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "NAME") + + +class FlowOutputStepOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "NAME") + + +class GenericLabelOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CATEGORY`: Sort by category + * `ID`: Sort by id + * `IS_ACTIVE`: Sort by isActive + * `IS_ELEVATED`: Sort by isElevated + * `LUID`: Sort by luid + * `VALUE`: Sort by value + """ + + __schema__ = tableau_schema + __choices__ = ("CATEGORY", "ID", "IS_ACTIVE", "IS_ELEVATED", "LUID", "VALUE") + + +class GroupFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DATA_CATEGORY`: Sort by dataCategory + * `DATA_TYPE`: Sort by dataType + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `IS_HIDDEN`: Sort by isHidden + * `NAME`: Sort by name + * `ROLE`: Sort by role + """ + + __schema__ = tableau_schema + __choices__ = ( + "DATA_CATEGORY", + "DATA_TYPE", + "DOWNSTREAM_SHEETS_COUNT", + "FIELDS_COUNT", + "ID", + "IS_HIDDEN", + "NAME", + "ROLE", + ) + + +class HierarchyFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `IS_HIDDEN`: Sort by isHidden + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("DOWNSTREAM_SHEETS_COUNT", "FIELDS_COUNT", "ID", "IS_HIDDEN", "NAME") + + +ID = sgqlc.types.ID + + +class InheritanceType(sgqlc.types.Enum): + """Method of selecting the objects (i.e., inheritance sources) to + inherit from + + Enumeration Choices: + + * `FIRST`: Inherit from the closest unambiguous upstream object + """ + + __schema__ = tableau_schema + __choices__ = ("FIRST",) + + +Int = sgqlc.types.Int + + +class LabelOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CATEGORY`: Sort by category + * `ID`: Sort by id + * `IS_ACTIVE`: Sort by isActive + * `IS_ELEVATED`: Sort by isElevated + * `LUID`: Sort by luid + * `VALUE`: Sort by value + """ + + __schema__ = tableau_schema + __choices__ = ("CATEGORY", "ID", "IS_ACTIVE", "IS_ELEVATED", "LUID", "VALUE") + + +class LensFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "NAME") + + +class LensOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `OWNER_COUNT`: Sort by owner count + * `VIZPORTAL_URL_ID`: Sort by vizportalUrlId + """ + + __schema__ = tableau_schema + __choices__ = ( + "FIELDS_COUNT", + "ID", + "LUID", + "NAME", + "OWNER_COUNT", + "VIZPORTAL_URL_ID", + ) + + +class LinkedFlowOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + """ + + __schema__ = tableau_schema + __choices__ = ("ID",) + + +class MetricDefinitionOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("FIELDS_COUNT", "ID", "LUID", "NAME") + + +class MetricOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONTAINER_NAME`: Sort by containerName + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `OWNER_COUNT`: Sort by owner count + * `PROJECT_NAME`: Sort by projectName + * `VIZPORTAL_URL_ID`: Sort by vizportalUrlId + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONTAINER_NAME", + "ID", + "LUID", + "NAME", + "OWNER_COUNT", + "PROJECT_NAME", + "VIZPORTAL_URL_ID", + ) + + +class NodeOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + """ + + __schema__ = tableau_schema + __choices__ = ("ID",) + + +class OrderDirection(sgqlc.types.Enum): + """General object for sorting + + Enumeration Choices: + + * `ASC`: Sort in an ascending order. + * `DESC`: Sort in a descending order. + """ + + __schema__ = tableau_schema + __choices__ = ("ASC", "DESC") + + +class ParameterOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `NAME`: Sort by name + * `PARENT_NAME`: Sort by parentName + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "NAME", "PARENT_NAME") + + +class PermissionMode(sgqlc.types.Enum): + """Enum of the different ways to apply permissions. + + Enumeration Choices: + + * `FILTER_RESULTS`: Filter out results user is not authorized on. + * `OBFUSCATE_RESULTS`: Include results that user is not authorized + to view with sensitive information obfuscated. + """ + + __schema__ = tableau_schema + __choices__ = ("FILTER_RESULTS", "OBFUSCATE_RESULTS") + + +class PublishedDatasourceOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONTAINER_NAME`: Sort by containerName + * `CONTAINS_UNSUPPORTED_CUSTOM_SQL`: Sort by + containsUnsupportedCustomSql + * `DOWNSTREAM_OWNERS_COUNT`: Sort by downstreamOwners count + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `FIELDS_COUNT`: Sort by fields count + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `OWNER_COUNT`: Sort by owner count + * `PROJECT_NAME`: Sort by projectName + * `VIZPORTAL_URL_ID`: Sort by vizportalUrlId + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONTAINER_NAME", + "CONTAINS_UNSUPPORTED_CUSTOM_SQL", + "DOWNSTREAM_OWNERS_COUNT", + "DOWNSTREAM_SHEETS_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "FIELDS_COUNT", + "HAS_ACTIVE_WARNING", + "ID", + "IS_CERTIFIED", + "LUID", + "NAME", + "OWNER_COUNT", + "PROJECT_NAME", + "VIZPORTAL_URL_ID", + ) + + +class RemoteType(sgqlc.types.Enum): + """Possible types of remote types Types correspond to OLEDB types + here: https://referencesource.microsoft.com/#system.data/System/Da + ta/OleDb/OLEDB_Enum.cs,364" Types prefixed with 'WDC' correspond + to Tableau's Web Data Connector types: https://tableau.github.io/w + ebdataconnector/docs/api_ref.html#webdataconnectorapi.datatypeenum + + Enumeration Choices: + + * `ARRAY`None + * `BOOL`None + * `BSTR`None + * `BYREF`None + * `BYTES`None + * `CY`None + * `DATE`None + * `DBDATE`None + * `DBTIME`None + * `DBTIMESTAMP`None + * `DECIMAL`None + * `EMPTY`None + * `ERROR`None + * `FILETIME`None + * `GUID`None + * `HCHAPTER`None + * `I1`None + * `I2`None + * `I4`None + * `I8`None + * `IDISPATCH`None + * `IUNKNOWN`None + * `NULL`None + * `NUMERIC`None + * `PROPVARIANT`None + * `R4`None + * `R8`None + * `RESERVED`None + * `STR`None + * `UDT`None + * `UI1`None + * `UI2`None + * `UI4`None + * `UI8`None + * `VARIANT`None + * `VARNUMERIC`None + * `VECTOR`None + * `WDC_BOOL`None + * `WDC_DATE`None + * `WDC_DATETIME`None + * `WDC_FLOAT`None + * `WDC_GEOMETRY`None + * `WDC_INT`None + * `WDC_STRING`None + * `WSTR`None + """ + + __schema__ = tableau_schema + __choices__ = ( + "ARRAY", + "BOOL", + "BSTR", + "BYREF", + "BYTES", + "CY", + "DATE", + "DBDATE", + "DBTIME", + "DBTIMESTAMP", + "DECIMAL", + "EMPTY", + "ERROR", + "FILETIME", + "GUID", + "HCHAPTER", + "I1", + "I2", + "I4", + "I8", + "IDISPATCH", + "IUNKNOWN", + "NULL", + "NUMERIC", + "PROPVARIANT", + "R4", + "R8", + "RESERVED", + "STR", + "UDT", + "UI1", + "UI2", + "UI4", + "UI8", + "VARIANT", + "VARNUMERIC", + "VECTOR", + "WDC_BOOL", + "WDC_DATE", + "WDC_DATETIME", + "WDC_FLOAT", + "WDC_GEOMETRY", + "WDC_INT", + "WDC_STRING", + "WSTR", + ) + + +class SetFieldOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DOWNSTREAM_SHEETS_COUNT`: Sort by downstreamSheets count + * `FIELDS_COUNT`: Sort by fields count + * `ID`: Sort by id + * `IS_HIDDEN`: Sort by isHidden + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("DOWNSTREAM_SHEETS_COUNT", "FIELDS_COUNT", "ID", "IS_HIDDEN", "NAME") + + +class SheetOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DATASOURCE_FIELDS_COUNT`: Sort by datasourceFields count + * `DOCUMENT_VIEW_ID`: Sort by documentViewId + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PATH`: Sort by path + * `SHEET_FIELD_INSTANCES_COUNT`: Sort by sheetFieldInstances count + * `WORKSHEET_FIELDS_COUNT`: Sort by worksheetFields count + """ + + __schema__ = tableau_schema + __choices__ = ( + "DATASOURCE_FIELDS_COUNT", + "DOCUMENT_VIEW_ID", + "ID", + "LUID", + "NAME", + "PATH", + "SHEET_FIELD_INSTANCES_COUNT", + "WORKSHEET_FIELDS_COUNT", + ) + + +String = sgqlc.types.String + + +class TableAdditionalDetailsOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + """ + + __schema__ = tableau_schema + __choices__ = ("ID",) + + +class TableOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `COLUMNS_COUNT`: Sort by columns count + * `DOWNSTREAM_DASHBOARDS_COUNT`: Sort by downstreamDashboards + count + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ( + "COLUMNS_COUNT", + "DOWNSTREAM_DASHBOARDS_COUNT", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "ID", + "NAME", + ) + + +class TableType(sgqlc.types.Enum): + """Possible types of table. TableType is DATABASETABLE unless the + object is a Salesforce Data Cloud object. A Salesforce Data Cloud + object's TableType is DATAMODEL, DATALAKE, or CALCULATED INSIGHT. + *Available in Tableau Cloud February 2024 / Server 2024.2 and + later.* + + Enumeration Choices: + + * `CALCULATEDINSIGHT`None + * `DATABASETABLE`None + * `DATALAKE`None + * `DATAMODEL`None + """ + + __schema__ = tableau_schema + __choices__ = ("CALCULATEDINSIGHT", "DATABASETABLE", "DATALAKE", "DATAMODEL") + + +class TableauSiteOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "LUID", "NAME") + + +class TableauUserOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DOMAIN`: Sort by domain + * `EMAIL`: Sort by email + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `USERNAME`: Sort by username + """ + + __schema__ = tableau_schema + __choices__ = ("DOMAIN", "EMAIL", "ID", "LUID", "NAME", "USERNAME") + + +class TagOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `NAME`: Sort by name + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "NAME") + + +class TaggableOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `ID`: Sort by id + * `LUID`: Sort by luid + """ + + __schema__ = tableau_schema + __choices__ = ("ID", "LUID") + + +class ViewOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `DOCUMENT_VIEW_ID`: Sort by documentViewId + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PATH`: Sort by path + """ + + __schema__ = tableau_schema + __choices__ = ("DOCUMENT_VIEW_ID", "ID", "LUID", "NAME", "PATH") + + +class VirtualConnectionOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONNECTION_TYPE`: Sort by connectionType + * `CONTAINER_NAME`: Sort by containerName + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `OWNER_COUNT`: Sort by owner count + * `PROJECT_NAME`: Sort by projectName + * `VIZPORTAL_URL_ID`: Sort by vizportalUrlId + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONNECTION_TYPE", + "CONTAINER_NAME", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "HAS_ACTIVE_WARNING", + "ID", + "IS_CERTIFIED", + "LUID", + "NAME", + "OWNER_COUNT", + "PROJECT_NAME", + "VIZPORTAL_URL_ID", + ) + + +class VirtualConnectionTableOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `COLUMNS_COUNT`: Sort by columns count + * `CONTAINS_UNSUPPORTED_CUSTOM_SQL`: Sort by + containsUnsupportedCustomSql + * `DOWNSTREAM_DASHBOARDS_COUNT`: Sort by downstreamDashboards + count + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `EXTRACT_LAST_REFRESHED_AT`: Sort by extractLastRefreshedAt + * `EXTRACT_LAST_REFRESH_TYPE`: Sort by extractLastRefreshType + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `IS_EXTRACTED`: Sort by isExtracted + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `OWNER_COUNT`: Sort by owner count + * `VIZPORTAL_URL_ID`: Sort by vizportalUrlId + """ + + __schema__ = tableau_schema + __choices__ = ( + "COLUMNS_COUNT", + "CONTAINS_UNSUPPORTED_CUSTOM_SQL", + "DOWNSTREAM_DASHBOARDS_COUNT", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "EXTRACT_LAST_REFRESHED_AT", + "EXTRACT_LAST_REFRESH_TYPE", + "HAS_ACTIVE_WARNING", + "ID", + "IS_CERTIFIED", + "IS_EXTRACTED", + "LUID", + "NAME", + "OWNER_COUNT", + "VIZPORTAL_URL_ID", + ) + + +class WarnableOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `LUID`: Sort by luid + """ + + __schema__ = tableau_schema + __choices__ = ("HAS_ACTIVE_WARNING", "ID", "LUID") + + +class WebDataConnectorOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONNECTION_TYPE`: Sort by connectionType + * `DOWNSTREAM_DATASOURCES_COUNT`: Sort by downstreamDatasources + count + * `DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT`: Sort by + downstreamVirtualConnections count + * `DOWNSTREAM_WORKBOOKS_COUNT`: Sort by downstreamWorkbooks count + * `HAS_ACTIVE_WARNING`: Sort by hasActiveWarning + * `ID`: Sort by id + * `IS_CERTIFIED`: Sort by isCertified + * `IS_EMBEDDED`: Sort by isEmbedded + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `PROJECT_NAME`: Sort by projectName + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONNECTION_TYPE", + "DOWNSTREAM_DATASOURCES_COUNT", + "DOWNSTREAM_VIRTUAL_CONNECTIONS_COUNT", + "DOWNSTREAM_WORKBOOKS_COUNT", + "HAS_ACTIVE_WARNING", + "ID", + "IS_CERTIFIED", + "IS_EMBEDDED", + "LUID", + "NAME", + "PROJECT_NAME", + ) + + +class WorkbookOrderField(sgqlc.types.Enum): + """Enum for fields that can be used for sorting + + Enumeration Choices: + + * `CONTAINER_NAME`: Sort by containerName + * `CONTAINS_UNSUPPORTED_CUSTOM_SQL`: Sort by + containsUnsupportedCustomSql + * `DASHBOARDS_COUNT`: Sort by dashboards count + * `EMBEDDED_DATASOURCES_COUNT`: Sort by embeddedDatasources count + * `ID`: Sort by id + * `LUID`: Sort by luid + * `NAME`: Sort by name + * `OWNER_COUNT`: Sort by owner count + * `PROJECT_LUID`: Sort by projectLuid + * `PROJECT_NAME`: Sort by projectName + * `SHEETS_COUNT`: Sort by sheets count + * `VIEWS_COUNT`: Sort by views count + * `VIZPORTAL_URL_ID`: Sort by vizportalUrlId + """ + + __schema__ = tableau_schema + __choices__ = ( + "CONTAINER_NAME", + "CONTAINS_UNSUPPORTED_CUSTOM_SQL", + "DASHBOARDS_COUNT", + "EMBEDDED_DATASOURCES_COUNT", + "ID", + "LUID", + "NAME", + "OWNER_COUNT", + "PROJECT_LUID", + "PROJECT_NAME", + "SHEETS_COUNT", + "VIEWS_COUNT", + "VIZPORTAL_URL_ID", + ) + + +######################################################################## +# Input Objects +######################################################################## +class AnalyticsFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(AnalyticsFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class AnalyticsField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique Identifier of object to retrieve""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique Identifier of object to retrieve""" + + +class AskDataExtensionSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(AskDataExtensionOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class AskDataExtension_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API""" + + +class AskDataExtension_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API""" + + +class BinFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(BinFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class BinField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_hidden", + "is_hidden_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + is_hidden_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isHiddenWithin" + ) + """True if the field is hidden""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class BinField_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class CalculatedFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(CalculatedFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class CalculatedField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_hidden", + "is_hidden_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + is_hidden_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isHiddenWithin" + ) + """True if the field is hidden""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class CalculatedField_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class CanHaveLabelsSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(CanHaveLabelsOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class CanHaveLabels_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "luid", "luid_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + +class CertifiableSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(CertifiableOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Certifiable_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_certified", + "is_certified_within", + "luid", + "luid_within", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this content item contains an active data quality + certification + """ + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this content item contains an active data quality + certification + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + +class CloudFileSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(CloudFileOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class CloudFile_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "connection_type", + "connection_type_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "is_certified", + "is_certified_within", + "is_embedded", + "is_embedded_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "text", + ) + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type shortname""" + + connection_type_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="connectionTypeWithin" + ) + """Connection type shortname""" + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the database has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the database has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this database contains an active data quality + certification + """ + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this database contains an active data quality + certification + """ + + is_embedded = sgqlc.types.Field(Boolean, graphql_name="isEmbedded") + """True if this file is embedded in Tableau content, e.g., a packaged + workbook + """ + + is_embedded_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isEmbeddedWithin" + ) + """True if this file is embedded in Tableau content, e.g., a packaged + workbook + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class ColumnFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(ColumnFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class ColumnField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_hidden", + "is_hidden_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + is_hidden_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isHiddenWithin" + ) + """True if the field is hidden""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class ColumnField_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class ColumnSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(ColumnOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Column_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "display_name", + "display_name_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "luid", + "luid_within", + "name", + "name_within", + ) + display_name = sgqlc.types.Field(String, graphql_name="displayName") + """Optional display name for column""" + + display_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="displayNameWithin" + ) + """Optional display name for column""" + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if this column has an active data quality warning. Available + in Tableau Cloud October 2022 / Server 2022.3 and later. + """ + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if this column has an active data quality warning. Available + in Tableau Cloud October 2022 / Server 2022.3 and later. + """ + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name of column""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name of column""" + + +class Column_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name of column""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name of column""" + + +class CombinedFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(CombinedFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class CombinedField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_hidden", + "is_hidden_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + is_hidden_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isHiddenWithin" + ) + """True if the field is hidden""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class CombinedField_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class CombinedSetFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(CombinedSetFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class CombinedSetField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_hidden", + "is_hidden_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + is_hidden_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isHiddenWithin" + ) + """True if the field is hidden""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class CombinedSetField_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class CustomSQLTableSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(CustomSQLTableOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class CustomSQLTable_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_unsupported_custom_sql", + "is_unsupported_custom_sql_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="isUnsupportedCustomSql" + ) + """True if the query is unsupported by Tableau Catalog, in which case + lineage may be incomplete + """ + + is_unsupported_custom_sql_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isUnsupportedCustomSqlWithin" + ) + """True if the query is unsupported by Tableau Catalog, in which case + lineage may be incomplete + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class DashboardSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DashboardOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Dashboard_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "document_view_id", + "document_view_id_within", + "id", + "id_within", + "luid", + "luid_within", + "name", + "name_within", + "path", + "path_within", + ) + document_view_id = sgqlc.types.Field(String, graphql_name="documentViewId") + """Unique ID for the dashboard generated for and stored within the + workbook, survives renames, and is used for internal processes + """ + + document_view_id_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="documentViewIdWithin" + ) + """Unique ID for the dashboard generated for and stored within the + workbook, survives renames, and is used for internal processes + """ + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server (Blank if worksheet is hidden in Workbook) + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server (Blank if worksheet is hidden in Workbook) + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + path = sgqlc.types.Field(String, graphql_name="path") + """Server path to dashboard""" + + path_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="pathWithin" + ) + """Server path to dashboard""" + + +class DataCloudSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DataCloudOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class DataCloud_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "connection_type", + "connection_type_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "is_certified", + "is_certified_within", + "is_embedded", + "is_embedded_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "text", + ) + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type shortname""" + + connection_type_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="connectionTypeWithin" + ) + """Connection type shortname""" + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the database has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the database has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used with the Metadata API. Not the same as the + locally unique identifier used with the REST API. + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used with the Metadata API. Not the same as the + locally unique identifier used with the REST API. + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this database contains an active data quality + certification + """ + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this database contains an active data quality + certification + """ + + is_embedded = sgqlc.types.Field(Boolean, graphql_name="isEmbedded") + """True if this database is embedded in Tableau content, e.g., a + packaged workbook + """ + + is_embedded_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isEmbeddedWithin" + ) + """True if this database is embedded in Tableau content, e.g., a + packaged workbook + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used with the REST API.""" + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used with the REST API.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class DataFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DataFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class DataField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique Identifier of object to retrieve""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique Identifier of object to retrieve""" + + +class DataQualityCertificationSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DataQualityCertificationOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class DataQualityCertification_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "category", + "category_within", + "id", + "id_within", + "is_active", + "is_active_within", + "is_elevated", + "is_elevated_within", + "luid", + "luid_within", + "value", + "value_within", + ) + category = sgqlc.types.Field(String, graphql_name="category") + """Category of the label""" + + category_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="categoryWithin" + ) + """Category of the label""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_active = sgqlc.types.Field(Boolean, graphql_name="isActive") + """True if the data quality certification is active""" + + is_active_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isActiveWithin" + ) + """True if the data quality certification is active""" + + is_elevated = sgqlc.types.Field(Boolean, graphql_name="isElevated") + """True if the data quality certification is elevated""" + + is_elevated_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isElevatedWithin" + ) + """True if the data quality certification is elevated""" + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + value = sgqlc.types.Field(String, graphql_name="value") + """Value of the label""" + + value_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="valueWithin" + ) + """Value of the label""" + + +class DataQualityWarningSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DataQualityWarningOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class DataQualityWarning_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "category", + "category_within", + "id", + "id_within", + "is_active", + "is_active_within", + "is_elevated", + "is_elevated_within", + "is_severe", + "is_severe_within", + "luid", + "luid_within", + "value", + "value_within", + "warning_type", + "warning_type_within", + ) + category = sgqlc.types.Field(String, graphql_name="category") + """Category of the label""" + + category_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="categoryWithin" + ) + """Category of the label""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_active = sgqlc.types.Field(Boolean, graphql_name="isActive") + """True if the data quality warning is active""" + + is_active_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isActiveWithin" + ) + """True if the data quality warning is active""" + + is_elevated = sgqlc.types.Field(Boolean, graphql_name="isElevated") + """True if the data quality warning is elevated""" + + is_elevated_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isElevatedWithin" + ) + """True if the data quality warning is elevated""" + + is_severe = sgqlc.types.Field(Boolean, graphql_name="isSevere") + """Synonymous with isElevated""" + + is_severe_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isSevereWithin" + ) + """Synonymous with isElevated""" + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + value = sgqlc.types.Field(String, graphql_name="value") + """Value of the label""" + + value_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="valueWithin" + ) + """Value of the label""" + + warning_type = sgqlc.types.Field(String, graphql_name="warningType") + """Synonymous with value""" + + warning_type_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="warningTypeWithin" + ) + """Synonymous with value""" + + +class DatabaseServerSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DatabaseServerOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class DatabaseServer_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "connection_type", + "connection_type_within", + "has_active_warning", + "has_active_warning_within", + "host_name", + "host_name_within", + "id", + "id_within", + "is_certified", + "is_certified_within", + "is_embedded", + "is_embedded_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "text", + ) + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type shortname""" + + connection_type_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="connectionTypeWithin" + ) + """Connection type shortname""" + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the database has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the database has an active data quality warning""" + + host_name = sgqlc.types.Field(String, graphql_name="hostName") + """Hostname of the database""" + + host_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="hostNameWithin" + ) + """Hostname of the database""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this database contains an active data quality + certification + """ + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this database contains an active data quality + certification + """ + + is_embedded = sgqlc.types.Field(Boolean, graphql_name="isEmbedded") + """A database server is never embedded in Tableau content""" + + is_embedded_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isEmbeddedWithin" + ) + """A database server is never embedded in Tableau content""" + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class DatabaseSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DatabaseOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class DatabaseTableSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DatabaseTableOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class DatabaseTable_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "connection_type", + "connection_type_within", + "full_name", + "full_name_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "is_certified", + "is_certified_within", + "is_embedded", + "is_embedded_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "schema", + "schema_within", + "text", + ) + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type of parent database""" + + connection_type_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="connectionTypeWithin" + ) + """Connection type of parent database""" + + full_name = sgqlc.types.Field(String, graphql_name="fullName") + """Fully qualified table name""" + + full_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="fullNameWithin" + ) + """Fully qualified table name""" + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the table has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the table has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this table contains an active data quality certification""" + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this table contains an active data quality certification""" + + is_embedded = sgqlc.types.Field(Boolean, graphql_name="isEmbedded") + """True if this table is embedded in Tableau content""" + + is_embedded_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isEmbeddedWithin" + ) + """True if this table is embedded in Tableau content""" + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the table is visible. Will be + empty if the table is not in a project. + """ + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project in which the table is visible. Will be + empty if the table is not in a project. + """ + + schema = sgqlc.types.Field(String, graphql_name="schema") + """Name of table schema. Note: For some databases, such as + Amazon Athena and Exasol, the schema attribute may not return the + correct schema name for the table. For more information, see + https://help.tableau.com/current/api/metadata_api/en- + us/docs/meta_api_model.html#schema_attribute. + """ + + schema_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="schemaWithin" + ) + """Name of table schema. Note: For some databases, such as + Amazon Athena and Exasol, the schema attribute may not return the + correct schema name for the table. For more information, see + https://help.tableau.com/current/api/metadata_api/en- + us/docs/meta_api_model.html#schema_attribute. + """ + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class Database_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "connection_type", + "connection_type_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "is_certified", + "is_certified_within", + "is_embedded", + "is_embedded_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "text", + ) + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type shortname""" + + connection_type_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="connectionTypeWithin" + ) + """Connection type shortname""" + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the database has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the database has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this database contains an active data quality + certification + """ + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this database contains an active data quality + certification + """ + + is_embedded = sgqlc.types.Field(Boolean, graphql_name="isEmbedded") + """True if this database is embedded in Tableau content, e.g., a + packaged workbook + """ + + is_embedded_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isEmbeddedWithin" + ) + """True if this database is embedded in Tableau content, e.g., a + packaged workbook + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class DatasourceFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DatasourceFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class DatasourceField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_hidden", + "is_hidden_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + is_hidden_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isHiddenWithin" + ) + """True if the field is hidden""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class DatasourceField_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class DatasourceFilterSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DatasourceFilterOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class DatasourceFilter_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + +class DatasourceSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(DatasourceOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Datasource_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "contains_unsupported_custom_sql", + "contains_unsupported_custom_sql_within", + "id", + "id_within", + "name", + "name_within", + ) + contains_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="containsUnsupportedCustomSql" + ) + """True if the datasource contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + contains_unsupported_custom_sql_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="containsUnsupportedCustomSqlWithin" + ) + """True if the datasource contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class EmbeddedDatasourceSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(EmbeddedDatasourceOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class EmbeddedDatasource_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "contains_unsupported_custom_sql", + "contains_unsupported_custom_sql_within", + "id", + "id_within", + "name", + "name_within", + ) + contains_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="containsUnsupportedCustomSql" + ) + """True if the datasource contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + contains_unsupported_custom_sql_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="containsUnsupportedCustomSqlWithin" + ) + """True if the datasource contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class ExtractType_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique Identifier of object to retrieve""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique Identifier of object to retrieve""" + + +class FieldDataType_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique Identifier of object to retrieve""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique Identifier of object to retrieve""" + + +class FieldReferencingFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FieldReferencingFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class FieldReferencingField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique Identifier of object to retrieve""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique Identifier of object to retrieve""" + + +class FieldRoleCategory_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique Identifier of object to retrieve""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique Identifier of object to retrieve""" + + +class FieldRole_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique Identifier of object to retrieve""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique Identifier of object to retrieve""" + + +class FieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Field_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_hidden", + "is_hidden_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + is_hidden_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isHiddenWithin" + ) + """True if the field is hidden""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class Field_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server""" + + +class FileSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FileOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class File_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "connection_type", + "connection_type_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "is_certified", + "is_certified_within", + "is_embedded", + "is_embedded_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "text", + ) + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type shortname""" + + connection_type_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="connectionTypeWithin" + ) + """Connection type shortname""" + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the database has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the database has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this database contains an active data quality + certification + """ + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this database contains an active data quality + certification + """ + + is_embedded = sgqlc.types.Field(Boolean, graphql_name="isEmbedded") + """True if this file is embedded in Tableau content, e.g., a packaged + workbook + """ + + is_embedded_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isEmbeddedWithin" + ) + """True if this file is embedded in Tableau content, e.g., a packaged + workbook + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class FlowColumnInputFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FlowColumnInputFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class FlowColumnInputField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class FlowColumnOutputFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FlowColumnOutputFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class FlowColumnOutputField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class FlowFieldInputFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FlowFieldInputFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class FlowFieldInputField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class FlowFieldOutputFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FlowFieldOutputFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class FlowFieldOutputField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class FlowInputFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FlowInputFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class FlowInputField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class FlowOutputFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FlowOutputFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class FlowOutputField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class FlowOutputStepSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FlowOutputStepOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class FlowOutputStep_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class FlowSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(FlowOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Flow_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "container_name", + "container_name_within", + "contains_unsupported_custom_sql", + "contains_unsupported_custom_sql_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "vizportal_url_id", + "vizportal_url_id_within", + ) + container_name = sgqlc.types.Field(String, graphql_name="containerName") + """The name of the container in which the flow is visible and usable. + Either a personal space or project. + """ + + container_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="containerNameWithin" + ) + """The name of the container in which the flow is visible and usable. + Either a personal space or project. + """ + + contains_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="containsUnsupportedCustomSql" + ) + """True if the flow contains unsupported custom SQL, in which case + lineage may be incomplete + """ + + contains_unsupported_custom_sql_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="containsUnsupportedCustomSqlWithin" + ) + """True if the flow contains unsupported custom SQL, in which case + lineage may be incomplete + """ + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the flow has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the flow has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the flow is visible and usable""" + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project in which the flow is visible and usable""" + + vizportal_url_id = sgqlc.types.Field(String, graphql_name="vizportalUrlId") + """VizPortal URL ID; used for URL generation""" + + vizportal_url_id_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="vizportalUrlIdWithin" + ) + """VizPortal URL ID; used for URL generation""" + + +class GenericLabelSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(GenericLabelOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class GenericLabel_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "category", + "category_within", + "id", + "id_within", + "is_active", + "is_active_within", + "is_elevated", + "is_elevated_within", + "luid", + "luid_within", + "value", + "value_within", + ) + category = sgqlc.types.Field(String, graphql_name="category") + """Category of the label""" + + category_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="categoryWithin" + ) + """Category of the label""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_active = sgqlc.types.Field(Boolean, graphql_name="isActive") + """True if the label is active""" + + is_active_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isActiveWithin" + ) + """True if the label is active""" + + is_elevated = sgqlc.types.Field(Boolean, graphql_name="isElevated") + """True if the label is elevated""" + + is_elevated_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isElevatedWithin" + ) + """True if the label is elevated""" + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + value = sgqlc.types.Field(String, graphql_name="value") + """Value of the label""" + + value_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="valueWithin" + ) + """Value of the label""" + + +class GroupFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(GroupFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class GroupField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_hidden", + "is_hidden_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + is_hidden_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isHiddenWithin" + ) + """True if the field is hidden""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class GroupField_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class HierarchyFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(HierarchyFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class HierarchyField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_hidden", + "is_hidden_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + is_hidden_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isHiddenWithin" + ) + """True if the field is hidden""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class HierarchyField_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class LabelSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(LabelOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Label_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "category", + "category_within", + "id", + "id_within", + "is_active", + "is_active_within", + "is_elevated", + "is_elevated_within", + "luid", + "luid_within", + "value", + "value_within", + ) + category = sgqlc.types.Field(String, graphql_name="category") + """Category of the label""" + + category_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="categoryWithin" + ) + """Category of the label""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_active = sgqlc.types.Field(Boolean, graphql_name="isActive") + """True if the label is active""" + + is_active_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isActiveWithin" + ) + """True if the label is active""" + + is_elevated = sgqlc.types.Field(Boolean, graphql_name="isElevated") + """True if the label is elevated""" + + is_elevated_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isElevatedWithin" + ) + """True if the label is elevated""" + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + value = sgqlc.types.Field(String, graphql_name="value") + """Value of the label""" + + value_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="valueWithin" + ) + """Value of the label""" + + +class LensFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(LensFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class LensField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name of field shown locally in Ask Data. If null or empty, use + name inherited from datasource field. + """ + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name of field shown locally in Ask Data. If null or empty, use + name inherited from datasource field. + """ + + +class LensField_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + +class LensSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(LensOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Lens_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "luid", + "luid_within", + "name", + "name_within", + "vizportal_url_id", + "vizportal_url_id_within", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server""" + + vizportal_url_id = sgqlc.types.Field(String, graphql_name="vizportalUrlId") + """VizPortal URL ID; used for URL generation""" + + vizportal_url_id_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="vizportalUrlIdWithin" + ) + """VizPortal URL ID; used for URL generation""" + + +class LinkedFlowSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(LinkedFlowOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class LinkedFlow_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique Identifier of object to retrieve""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique Identifier of object to retrieve""" + + +class MetricDefinitionSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(MetricDefinitionOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class MetricDefinition_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "luid", "luid_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the Metadata API. Not the same as the + locally unique identifier used with the REST API. + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the Metadata API. Not the same as the + locally unique identifier used with the REST API. + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server. + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server. + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name of the metric definition.""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name of the metric definition.""" + + +class MetricSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(MetricOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Metric_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "container_name", + "container_name_within", + "id", + "id_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "vizportal_url_id", + "vizportal_url_id_within", + ) + container_name = sgqlc.types.Field(String, graphql_name="containerName") + """The name of the container in which the metric is visible and + usable. This is always a project. + """ + + container_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="containerNameWithin" + ) + """The name of the container in which the metric is visible and + usable. This is always a project. + """ + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the Metric is visible and usable.""" + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project in which the Metric is visible and usable.""" + + vizportal_url_id = sgqlc.types.Field(String, graphql_name="vizportalUrlId") + """VizPortal URL ID; used for URL generation""" + + vizportal_url_id_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="vizportalUrlIdWithin" + ) + """VizPortal URL ID; used for URL generation""" + + +class NodeSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(NodeOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Node_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + +class ParameterSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(ParameterOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Parameter_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "name", + "name_within", + "parent_name", + "parent_name_within", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name of parameter""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name of parameter""" + + parent_name = sgqlc.types.Field(String, graphql_name="parentName") + """Name of the parameter's parent""" + + parent_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="parentNameWithin" + ) + """Name of the parameter's parent""" + + +class PublishedDatasourceSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(PublishedDatasourceOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class PublishedDatasource_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "container_name", + "container_name_within", + "contains_unsupported_custom_sql", + "contains_unsupported_custom_sql_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "is_certified", + "is_certified_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "vizportal_url_id", + "vizportal_url_id_within", + ) + container_name = sgqlc.types.Field(String, graphql_name="containerName") + """The name of the container in which the published data source is + visible and usable. Either a personal space or project. + """ + + container_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="containerNameWithin" + ) + """The name of the container in which the published data source is + visible and usable. Either a personal space or project. + """ + + contains_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="containsUnsupportedCustomSql" + ) + """True if the datasource contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + contains_unsupported_custom_sql_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="containsUnsupportedCustomSqlWithin" + ) + """True if the datasource contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the data source has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the data source has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this data source contains an active data quality + certification + """ + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this data source contains an active data quality + certification + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project that contains this published data source.""" + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project that contains this published data source.""" + + vizportal_url_id = sgqlc.types.Field(String, graphql_name="vizportalUrlId") + """VizPortal URL ID; used for URL generation""" + + vizportal_url_id_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="vizportalUrlIdWithin" + ) + """VizPortal URL ID; used for URL generation""" + + +class RemoteType_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique Identifier of object to retrieve""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique Identifier of object to retrieve""" + + +class SetFieldSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(SetFieldOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class SetField_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "id", + "id_within", + "is_hidden", + "is_hidden_within", + "name", + "name_within", + "text", + ) + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + is_hidden_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isHiddenWithin" + ) + """True if the field is hidden""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class SetField_Required_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + +class SheetSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(SheetOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Sheet_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "document_view_id", + "document_view_id_within", + "id", + "id_within", + "luid", + "luid_within", + "name", + "name_within", + "path", + "path_within", + ) + document_view_id = sgqlc.types.Field(String, graphql_name="documentViewId") + """Unique ID for the sheet generated for and stored within the + workbook, survives renames, and is used for internal processes + """ + + document_view_id_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="documentViewIdWithin" + ) + """Unique ID for the sheet generated for and stored within the + workbook, survives renames, and is used for internal processes + """ + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server (Blank if worksheet is hidden in Workbook) + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server (Blank if worksheet is hidden in Workbook) + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + path = sgqlc.types.Field(String, graphql_name="path") + """Server path to sheet""" + + path_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="pathWithin" + ) + """Server path to sheet""" + + +class TableAdditionalDetailsSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(TableAdditionalDetailsOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class TableAdditionalDetails_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used with the Metadata API. Not the same as the + locally unique identifier used with the REST API. + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used with the Metadata API. Not the same as the + locally unique identifier used with the REST API. + """ + + +class TableSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(TableOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class TableType_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique Identifier of object to retrieve""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique Identifier of object to retrieve""" + + +class Table_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within", "text") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class TableauSiteSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(TableauSiteOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class TableauSite_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "luid", "luid_within", "name", "name_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server""" + + +class TableauUserSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(TableauUserOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class TableauUser_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "domain", + "domain_within", + "email", + "email_within", + "id", + "id_within", + "luid", + "luid_within", + "name", + "name_within", + "username", + "username_within", + ) + domain = sgqlc.types.Field(String, graphql_name="domain") + """Domain this user belongs to""" + + domain_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="domainWithin" + ) + """Domain this user belongs to""" + + email = sgqlc.types.Field(String, graphql_name="email") + """Email address of this user""" + + email_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="emailWithin" + ) + """Email address of this user""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Display name of this user""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Display name of this user""" + + username = sgqlc.types.Field(String, graphql_name="username") + """Username of this user""" + + username_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="usernameWithin" + ) + """Username of this user""" + + +class TagSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field(sgqlc.types.non_null(TagOrderField), graphql_name="field") + """GraphQL field to sort on""" + + +class Tag_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "name", "name_within", "text") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API.""" + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of the tag""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """The name of the tag""" + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class TaggableSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(TaggableOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Taggable_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ("id", "id_within", "luid", "luid_within") + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + +class ViewSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(ViewOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class View_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "document_view_id", + "document_view_id_within", + "id", + "id_within", + "luid", + "luid_within", + "name", + "name_within", + "path", + "path_within", + ) + document_view_id = sgqlc.types.Field(String, graphql_name="documentViewId") + """Unique ID for the view generated for and stored within the + workbook, survives renames, and is used for internal processes + """ + + document_view_id_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="documentViewIdWithin" + ) + """Unique ID for the view generated for and stored within the + workbook, survives renames, and is used for internal processes + """ + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server (Blank if sheet is hidden in Workbook) + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server (Blank if sheet is hidden in Workbook) + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + path = sgqlc.types.Field(String, graphql_name="path") + """Server path to view""" + + path_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="pathWithin" + ) + """Server path to view""" + + +class VirtualConnectionSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(VirtualConnectionOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class VirtualConnectionTableSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(VirtualConnectionTableOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class VirtualConnectionTable_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "contains_unsupported_custom_sql", + "contains_unsupported_custom_sql_within", + "extract_last_refreshed_at", + "extract_last_refreshed_at_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "is_certified", + "is_certified_within", + "is_extracted", + "is_extracted_within", + "luid", + "luid_within", + "name", + "name_within", + "vizportal_url_id", + "vizportal_url_id_within", + ) + contains_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="containsUnsupportedCustomSql" + ) + """True if the datasource contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + contains_unsupported_custom_sql_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="containsUnsupportedCustomSqlWithin" + ) + """True if the datasource contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + extract_last_refreshed_at = sgqlc.types.Field( + DateTime, graphql_name="extractLastRefreshedAt" + ) + """The time the data for this table's extract was refreshed.""" + + extract_last_refreshed_at_within = sgqlc.types.Field( + sgqlc.types.list_of(DateTime), graphql_name="extractLastRefreshedAtWithin" + ) + """The time the data for this table's extract was refreshed.""" + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the table has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the table has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this virtual connection table contains an active data + quality certification + """ + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this virtual connection table contains an active data + quality certification + """ + + is_extracted = sgqlc.types.Field(Boolean, graphql_name="isExtracted") + """Whether or not queries to this table are using an extract.""" + + is_extracted_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isExtractedWithin" + ) + """Whether or not queries to this table are using an extract.""" + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + vizportal_url_id = sgqlc.types.Field(String, graphql_name="vizportalUrlId") + """VizPortal URL ID; used for URL generation""" + + vizportal_url_id_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="vizportalUrlIdWithin" + ) + """VizPortal URL ID; used for URL generation""" + + +class VirtualConnection_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "connection_type", + "connection_type_within", + "container_name", + "container_name_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "is_certified", + "is_certified_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "vizportal_url_id", + "vizportal_url_id_within", + ) + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type of this virtual connection""" + + connection_type_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="connectionTypeWithin" + ) + """Connection type of this virtual connection""" + + container_name = sgqlc.types.Field(String, graphql_name="containerName") + """The name of the container in which the virtual connection is + visible and usable. Either a personal space or project. + """ + + container_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="containerNameWithin" + ) + """The name of the container in which the virtual connection is + visible and usable. Either a personal space or project. + """ + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the virtual connection has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the virtual connection has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this virtual connection contains an active data quality + certification + """ + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this virtual connection contains an active data quality + certification + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project that contains this virtual connection.""" + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project that contains this virtual connection.""" + + vizportal_url_id = sgqlc.types.Field(String, graphql_name="vizportalUrlId") + """Vizportal URL ID; used for URL generation""" + + vizportal_url_id_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="vizportalUrlIdWithin" + ) + """Vizportal URL ID; used for URL generation""" + + +class WarnableSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(WarnableOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Warnable_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "luid", + "luid_within", + ) + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the content has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the content has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + +class WebDataConnectorSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(WebDataConnectorOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class WebDataConnector_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "connection_type", + "connection_type_within", + "has_active_warning", + "has_active_warning_within", + "id", + "id_within", + "is_certified", + "is_certified_within", + "is_embedded", + "is_embedded_within", + "luid", + "luid_within", + "name", + "name_within", + "project_name", + "project_name_within", + "text", + ) + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """The type of web data connector""" + + connection_type_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="connectionTypeWithin" + ) + """The type of web data connector""" + + has_active_warning = sgqlc.types.Field(Boolean, graphql_name="hasActiveWarning") + """True if the database has an active data quality warning""" + + has_active_warning_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="hasActiveWarningWithin" + ) + """True if the database has an active data quality warning""" + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field(Boolean, graphql_name="isCertified") + """True if this database contains an active data quality + certification + """ + + is_certified_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isCertifiedWithin" + ) + """True if this database contains an active data quality + certification + """ + + is_embedded = sgqlc.types.Field(Boolean, graphql_name="isEmbedded") + """A web data connector is always embedded in Tableau content""" + + is_embedded_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="isEmbeddedWithin" + ) + """A web data connector is always embedded in Tableau content""" + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + text = sgqlc.types.Field(String, graphql_name="text") + """Filter the output based on text query.""" + + +class WorkbookSortOrder(sgqlc.types.Input): + """Sort by given fields. The sort orders defined first in the list + will take priority. If there are no given sort orders or a tie on + the final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + __schema__ = tableau_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field( + sgqlc.types.non_null(OrderDirection), graphql_name="direction" + ) + """Order direction to sort output""" + + field = sgqlc.types.Field( + sgqlc.types.non_null(WorkbookOrderField), graphql_name="field" + ) + """GraphQL field to sort on""" + + +class Workbook_Filter(sgqlc.types.Input): + """Filter by GraphQL field and given value""" + + __schema__ = tableau_schema + __field_names__ = ( + "container_name", + "container_name_within", + "contains_unsupported_custom_sql", + "contains_unsupported_custom_sql_within", + "id", + "id_within", + "luid", + "luid_within", + "name", + "name_within", + "project_luid", + "project_luid_within", + "project_name", + "project_name_within", + "vizportal_url_id", + "vizportal_url_id_within", + ) + container_name = sgqlc.types.Field(String, graphql_name="containerName") + """The name of the container in which the workbook is visible and + usable. Either a personal space or project. + """ + + container_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="containerNameWithin" + ) + """The name of the container in which the workbook is visible and + usable. Either a personal space or project. + """ + + contains_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="containsUnsupportedCustomSql" + ) + """True if the workbook contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + contains_unsupported_custom_sql_within = sgqlc.types.Field( + sgqlc.types.list_of(Boolean), graphql_name="containsUnsupportedCustomSqlWithin" + ) + """True if the workbook contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + id = sgqlc.types.Field(ID, graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + id_within = sgqlc.types.Field(sgqlc.types.list_of(ID), graphql_name="idWithin") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(String, graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="luidWithin" + ) + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="nameWithin" + ) + """Name shown in server and desktop clients""" + + project_luid = sgqlc.types.Field(String, graphql_name="projectLuid") + """The luid of the project in which the workbook is visible and + usable. Available in Tableau Cloud June 2022 / Server 2022.3 and + later. + """ + + project_luid_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectLuidWithin" + ) + """The luid of the project in which the workbook is visible and + usable. Available in Tableau Cloud June 2022 / Server 2022.3 and + later. + """ + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the workbook is visible and + usable. + """ + + project_name_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="projectNameWithin" + ) + """The name of the project in which the workbook is visible and + usable. + """ + + vizportal_url_id = sgqlc.types.Field(String, graphql_name="vizportalUrlId") + """VizPortal URL ID; used for URL generation""" + + vizportal_url_id_within = sgqlc.types.Field( + sgqlc.types.list_of(String), graphql_name="vizportalUrlIdWithin" + ) + """VizPortal URL ID; used for URL generation""" + + +######################################################################## +# Output Objects and Interfaces +######################################################################## +class AnalyticsField(sgqlc.types.Interface): + """Base GraphQL type for a field containing analytics metadata""" + + __schema__ = tableau_schema + __field_names__ = ( + "aggregation", + "aggregation_param", + "datasource", + "default_format", + "derived_lens_fields", + "derived_lens_fields_connection", + "direct_sheets", + "direct_sheets_connection", + "metric_definitions", + "metric_definitions_connection", + "referenced_by_bins", + "referenced_by_bins_connection", + "referenced_by_calculations", + "referenced_by_calculations_connection", + "referenced_by_combined_fields", + "referenced_by_combined_fields_connection", + "referenced_by_combined_sets", + "referenced_by_combined_sets_connection", + "referenced_by_fields", + "referenced_by_fields_connection", + "referenced_by_filters", + "referenced_by_filters_connection", + "referenced_by_flow_field_input_field", + "referenced_by_flow_field_input_field_connection", + "referenced_by_flow_field_output_field", + "referenced_by_flow_field_output_field_connection", + "referenced_by_groups", + "referenced_by_groups_connection", + "referenced_by_hierarchies", + "referenced_by_hierarchies_connection", + "referenced_by_remote_fields", + "referenced_by_remote_fields_connection", + "referenced_by_sets", + "referenced_by_sets_connection", + "semantic_role", + "sheets", + "sheets_connection", + ) + aggregation = sgqlc.types.Field(String, graphql_name="aggregation") + """Default aggregation of the field, i.e. 'Sum', 'Average'. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/calculations_aggregation.html#AggFuncs + """ + + aggregation_param = sgqlc.types.Field(String, graphql_name="aggregationParam") + """For the percentile aggregation, the percentile number""" + + datasource = sgqlc.types.Field("Datasource", graphql_name="datasource") + """Data source that contains this field""" + + default_format = sgqlc.types.Field(String, graphql_name="defaultFormat") + """Default format for number or date""" + + derived_lens_fields = sgqlc.types.Field( + sgqlc.types.list_of("LensField"), + graphql_name="derivedLensFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of lens fields which are derived from this field + + Arguments: + + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + derived_lens_fields_connection = sgqlc.types.Field( + "LensFieldsConnection", + graphql_name="derivedLensFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of lens fields which are derived from this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + direct_sheets = sgqlc.types.Field( + sgqlc.types.list_of("Sheet"), + graphql_name="directSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this field + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + direct_sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="directSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metric_definitions = sgqlc.types.Field( + sgqlc.types.list_of("MetricDefinition"), + graphql_name="metricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions that reference this data source field. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metric_definitions_connection = sgqlc.types.Field( + "MetricDefinitionsConnection", + graphql_name="metricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions that reference this data source field. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_bins = sgqlc.types.Field( + sgqlc.types.list_of("BinField"), + graphql_name="referencedByBins", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The bin field that references this field + + Arguments: + + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_bins_connection = sgqlc.types.Field( + "BinFieldsConnection", + graphql_name="referencedByBinsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The bin field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_calculations = sgqlc.types.Field( + sgqlc.types.list_of("CalculatedField"), + graphql_name="referencedByCalculations", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The calculated field that references this field + + Arguments: + + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_calculations_connection = sgqlc.types.Field( + "CalculatedFieldsConnection", + graphql_name="referencedByCalculationsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The calculated field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_fields = sgqlc.types.Field( + sgqlc.types.list_of("CombinedField"), + graphql_name="referencedByCombinedFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CombinedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CombinedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The combined field that references this field + + Arguments: + + * `filter` (`CombinedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CombinedFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_fields_connection = sgqlc.types.Field( + "CombinedFieldsConnection", + graphql_name="referencedByCombinedFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CombinedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CombinedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The combined field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CombinedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CombinedFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_sets = sgqlc.types.Field( + sgqlc.types.list_of("CombinedSetField"), + graphql_name="referencedByCombinedSets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CombinedSetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CombinedSetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Thie combined set field that references this field + + Arguments: + + * `filter` (`CombinedSetField_Filter`): Filter by GraphQL field + and given value + * `order_by` (`CombinedSetFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_sets_connection = sgqlc.types.Field( + "CombinedSetFieldsConnection", + graphql_name="referencedByCombinedSetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CombinedSetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CombinedSetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Thie combined set field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CombinedSetField_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CombinedSetFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_fields = sgqlc.types.Field( + sgqlc.types.list_of("FieldReferencingField"), + graphql_name="referencedByFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FieldReferencingField_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldReferencingFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this field + + Arguments: + + * `filter` (`FieldReferencingField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FieldReferencingFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_fields_connection = sgqlc.types.Field( + "FieldReferencingFieldsConnection", + graphql_name="referencedByFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FieldReferencingField_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldReferencingFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FieldReferencingField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldReferencingFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_filters = sgqlc.types.Field( + sgqlc.types.list_of("DatasourceFilter"), + graphql_name="referencedByFilters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data source filters that include this field + + Arguments: + + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_filters_connection = sgqlc.types.Field( + "DatasourceFiltersConnection", + graphql_name="referencedByFiltersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data source filters that include this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_field_input_field = sgqlc.types.Field( + sgqlc.types.list_of("FlowFieldInputField"), + graphql_name="referencedByFlowFieldInputField", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldInputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """A flow input field that wraps this field + + Arguments: + + * `filter` (`FlowFieldInputField_Filter`): Filter by GraphQL field + and given value + * `order_by` (`FlowFieldInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + referenced_by_flow_field_input_field_connection = sgqlc.types.Field( + "FlowFieldInputFieldsConnection", + graphql_name="referencedByFlowFieldInputFieldConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldInputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """A flow input field that wraps this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldInputField_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + referenced_by_flow_field_output_field = sgqlc.types.Field( + sgqlc.types.list_of("FlowFieldOutputField"), + graphql_name="referencedByFlowFieldOutputField", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow output field that wraps this field + + Arguments: + + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_field_output_field_connection = sgqlc.types.Field( + "FlowFieldOutputFieldsConnection", + graphql_name="referencedByFlowFieldOutputFieldConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow output field that wraps this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_groups = sgqlc.types.Field( + sgqlc.types.list_of("GroupField"), + graphql_name="referencedByGroups", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + GroupField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + GroupFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The group field that references this field + + Arguments: + + * `filter` (`GroupField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`GroupFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_groups_connection = sgqlc.types.Field( + "GroupFieldsConnection", + graphql_name="referencedByGroupsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + GroupField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + GroupFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The group field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`GroupField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`GroupFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_hierarchies = sgqlc.types.Field( + sgqlc.types.list_of("HierarchyField"), + graphql_name="referencedByHierarchies", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + HierarchyField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + HierarchyFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The hierarchy field that references this field + + Arguments: + + * `filter` (`HierarchyField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`HierarchyFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_hierarchies_connection = sgqlc.types.Field( + "HierarchyFieldsConnection", + graphql_name="referencedByHierarchiesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + HierarchyField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + HierarchyFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The hierarchy field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`HierarchyField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`HierarchyFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_remote_fields = sgqlc.types.Field( + sgqlc.types.list_of("DatasourceField"), + graphql_name="referencedByRemoteFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this remote field + + Arguments: + + * `filter` (`DatasourceField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatasourceFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_remote_fields_connection = sgqlc.types.Field( + "DatasourceFieldsConnection", + graphql_name="referencedByRemoteFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this remote field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_sets = sgqlc.types.Field( + sgqlc.types.list_of("SetField"), + graphql_name="referencedBySets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The set field that this field references + + Arguments: + + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_sets_connection = sgqlc.types.Field( + "SetFieldsConnection", + graphql_name="referencedBySetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The set field that this field references + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + semantic_role = sgqlc.types.Field(String, graphql_name="semanticRole") + """For geographic data, the geographic role of the field. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/maps_geographicroles.html + """ + + sheets = sgqlc.types.Field( + sgqlc.types.list_of("Sheet"), + graphql_name="sheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this data source field + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="sheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this data source field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class CanHaveLabels(sgqlc.types.Interface): + """A content item that can have labels. *Available in Tableau Cloud + March 2023 / Server 2023.1 and later.* + """ + + __schema__ = tableau_schema + __field_names__ = ("id", "labels", "labels_connection", "luid", "name") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Label"))), + graphql_name="labels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The labels on a content item. Available in Tableau Cloud March + 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + labels_connection = sgqlc.types.Field( + "LabelsConnection", + graphql_name="labelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The labels on a content item. Available in Tableau Cloud March + 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of the asset""" + + +class Certifiable(sgqlc.types.Interface): + """A content item that can be certified""" + + __schema__ = tableau_schema + __field_names__ = ( + "data_quality_certifications", + "data_quality_certifications_connection", + "id", + "is_certified", + "luid", + "name", + ) + data_quality_certifications = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DataQualityCertification")) + ), + graphql_name="dataQualityCertifications", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityCertification_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityCertificationSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality certifications on a content item + + Arguments: + + * `filter` (`DataQualityCertification_Filter`): Filter by GraphQL + field and given value + * `order_by` (`DataQualityCertificationSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_quality_certifications_connection = sgqlc.types.Field( + "DataQualityCertificationsConnection", + graphql_name="dataQualityCertificationsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityCertification_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityCertificationSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality certifications on a content item + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityCertification_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityCertificationSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="isCertified" + ) + """True if this content item contains an active data quality + certification + """ + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of the asset""" + + +class DataField(sgqlc.types.Interface): + """Base GraphQL type for a field containing data. Most types of + Fields will implement this interface with exceptions like + HierarchyField. + """ + + __schema__ = tableau_schema + __field_names__ = ( + "data_category", + "data_type", + "datasource", + "derived_lens_fields", + "derived_lens_fields_connection", + "direct_sheets", + "direct_sheets_connection", + "metric_definitions", + "metric_definitions_connection", + "referenced_by_bins", + "referenced_by_bins_connection", + "referenced_by_calculations", + "referenced_by_calculations_connection", + "referenced_by_combined_fields", + "referenced_by_combined_fields_connection", + "referenced_by_combined_sets", + "referenced_by_combined_sets_connection", + "referenced_by_fields", + "referenced_by_fields_connection", + "referenced_by_filters", + "referenced_by_filters_connection", + "referenced_by_flow_field_input_field", + "referenced_by_flow_field_input_field_connection", + "referenced_by_flow_field_output_field", + "referenced_by_flow_field_output_field_connection", + "referenced_by_groups", + "referenced_by_groups_connection", + "referenced_by_hierarchies", + "referenced_by_hierarchies_connection", + "referenced_by_remote_fields", + "referenced_by_remote_fields_connection", + "referenced_by_sets", + "referenced_by_sets_connection", + "role", + "sheets", + "sheets_connection", + ) + data_category = sgqlc.types.Field(FieldRoleCategory, graphql_name="dataCategory") + """Data category of the field""" + + data_type = sgqlc.types.Field(FieldDataType, graphql_name="dataType") + """Type of the data in the field. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/datafields_typesandroles_datatypes.html + """ + + datasource = sgqlc.types.Field("Datasource", graphql_name="datasource") + """Data source that contains this field""" + + derived_lens_fields = sgqlc.types.Field( + sgqlc.types.list_of("LensField"), + graphql_name="derivedLensFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of lens fields which are derived from this field + + Arguments: + + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + derived_lens_fields_connection = sgqlc.types.Field( + "LensFieldsConnection", + graphql_name="derivedLensFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of lens fields which are derived from this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + direct_sheets = sgqlc.types.Field( + sgqlc.types.list_of("Sheet"), + graphql_name="directSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this field + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + direct_sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="directSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metric_definitions = sgqlc.types.Field( + sgqlc.types.list_of("MetricDefinition"), + graphql_name="metricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions that reference this data source field. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metric_definitions_connection = sgqlc.types.Field( + "MetricDefinitionsConnection", + graphql_name="metricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions that reference this data source field. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_bins = sgqlc.types.Field( + sgqlc.types.list_of("BinField"), + graphql_name="referencedByBins", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The bin field that references this field + + Arguments: + + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_bins_connection = sgqlc.types.Field( + "BinFieldsConnection", + graphql_name="referencedByBinsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The bin field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_calculations = sgqlc.types.Field( + sgqlc.types.list_of("CalculatedField"), + graphql_name="referencedByCalculations", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The calculated field that references this field + + Arguments: + + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_calculations_connection = sgqlc.types.Field( + "CalculatedFieldsConnection", + graphql_name="referencedByCalculationsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The calculated field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_fields = sgqlc.types.Field( + sgqlc.types.list_of("CombinedField"), + graphql_name="referencedByCombinedFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CombinedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CombinedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The combined field that references this field + + Arguments: + + * `filter` (`CombinedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CombinedFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_fields_connection = sgqlc.types.Field( + "CombinedFieldsConnection", + graphql_name="referencedByCombinedFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CombinedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CombinedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The combined field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CombinedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CombinedFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_sets = sgqlc.types.Field( + sgqlc.types.list_of("CombinedSetField"), + graphql_name="referencedByCombinedSets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CombinedSetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CombinedSetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Thie combined set field that references this field + + Arguments: + + * `filter` (`CombinedSetField_Filter`): Filter by GraphQL field + and given value + * `order_by` (`CombinedSetFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_sets_connection = sgqlc.types.Field( + "CombinedSetFieldsConnection", + graphql_name="referencedByCombinedSetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CombinedSetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CombinedSetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Thie combined set field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CombinedSetField_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CombinedSetFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_fields = sgqlc.types.Field( + sgqlc.types.list_of("FieldReferencingField"), + graphql_name="referencedByFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FieldReferencingField_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldReferencingFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this field + + Arguments: + + * `filter` (`FieldReferencingField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FieldReferencingFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_fields_connection = sgqlc.types.Field( + "FieldReferencingFieldsConnection", + graphql_name="referencedByFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FieldReferencingField_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldReferencingFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FieldReferencingField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldReferencingFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_filters = sgqlc.types.Field( + sgqlc.types.list_of("DatasourceFilter"), + graphql_name="referencedByFilters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data source filters that include this field + + Arguments: + + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_filters_connection = sgqlc.types.Field( + "DatasourceFiltersConnection", + graphql_name="referencedByFiltersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data source filters that include this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_field_input_field = sgqlc.types.Field( + sgqlc.types.list_of("FlowFieldInputField"), + graphql_name="referencedByFlowFieldInputField", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldInputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """A flow input field that wraps this field + + Arguments: + + * `filter` (`FlowFieldInputField_Filter`): Filter by GraphQL field + and given value + * `order_by` (`FlowFieldInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + referenced_by_flow_field_input_field_connection = sgqlc.types.Field( + "FlowFieldInputFieldsConnection", + graphql_name="referencedByFlowFieldInputFieldConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldInputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """A flow input field that wraps this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldInputField_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + referenced_by_flow_field_output_field = sgqlc.types.Field( + sgqlc.types.list_of("FlowFieldOutputField"), + graphql_name="referencedByFlowFieldOutputField", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow output field that wraps this field + + Arguments: + + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_field_output_field_connection = sgqlc.types.Field( + "FlowFieldOutputFieldsConnection", + graphql_name="referencedByFlowFieldOutputFieldConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow output field that wraps this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_groups = sgqlc.types.Field( + sgqlc.types.list_of("GroupField"), + graphql_name="referencedByGroups", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + GroupField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + GroupFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The group field that references this field + + Arguments: + + * `filter` (`GroupField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`GroupFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_groups_connection = sgqlc.types.Field( + "GroupFieldsConnection", + graphql_name="referencedByGroupsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + GroupField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + GroupFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The group field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`GroupField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`GroupFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_hierarchies = sgqlc.types.Field( + sgqlc.types.list_of("HierarchyField"), + graphql_name="referencedByHierarchies", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + HierarchyField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + HierarchyFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The hierarchy field that references this field + + Arguments: + + * `filter` (`HierarchyField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`HierarchyFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_hierarchies_connection = sgqlc.types.Field( + "HierarchyFieldsConnection", + graphql_name="referencedByHierarchiesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + HierarchyField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + HierarchyFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The hierarchy field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`HierarchyField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`HierarchyFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_remote_fields = sgqlc.types.Field( + sgqlc.types.list_of("DatasourceField"), + graphql_name="referencedByRemoteFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this remote field + + Arguments: + + * `filter` (`DatasourceField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatasourceFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_remote_fields_connection = sgqlc.types.Field( + "DatasourceFieldsConnection", + graphql_name="referencedByRemoteFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this remote field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_sets = sgqlc.types.Field( + sgqlc.types.list_of("SetField"), + graphql_name="referencedBySets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The set field that this field references + + Arguments: + + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_sets_connection = sgqlc.types.Field( + "SetFieldsConnection", + graphql_name="referencedBySetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The set field that this field references + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + role = sgqlc.types.Field(FieldRole, graphql_name="role") + """Role of the field: 'dimension', 'measure' or 'unknown' """ + + sheets = sgqlc.types.Field( + sgqlc.types.list_of("Sheet"), + graphql_name="sheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this data source field + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="sheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this data source field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class Database(sgqlc.types.Interface): + """A database containing tables""" + + __schema__ = tableau_schema + __field_names__ = ( + "certification_note", + "certifier", + "connection_type", + "contact", + "data_quality_certifications", + "data_quality_certifications_connection", + "data_quality_warning", + "data_quality_warnings", + "data_quality_warnings_connection", + "description", + "downstream_dashboards", + "downstream_dashboards_connection", + "downstream_databases", + "downstream_databases_connection", + "downstream_datasources", + "downstream_datasources_connection", + "downstream_flows", + "downstream_flows_connection", + "downstream_lenses", + "downstream_lenses_connection", + "downstream_metric_definitions", + "downstream_metric_definitions_connection", + "downstream_metrics", + "downstream_metrics_connection", + "downstream_owners", + "downstream_owners_connection", + "downstream_sheets", + "downstream_sheets_connection", + "downstream_tables", + "downstream_tables_connection", + "downstream_virtual_connection_tables", + "downstream_virtual_connection_tables_connection", + "downstream_virtual_connections", + "downstream_virtual_connections_connection", + "downstream_workbooks", + "downstream_workbooks_connection", + "has_active_warning", + "id", + "is_certified", + "is_controlled_permissions_enabled", + "is_embedded", + "is_grouped", + "labels", + "labels_connection", + "luid", + "name", + "project_name", + "project_vizportal_url_id", + "referenced_by_queries", + "referenced_by_queries_connection", + "tables", + "tables_connection", + "tags", + "tags_connection", + "upstream_data_quality_warnings", + "upstream_data_quality_warnings_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_labels", + "upstream_labels_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "upstream_virtual_connections", + "upstream_virtual_connections_connection", + "vizportal_id", + ) + certification_note = sgqlc.types.Field(String, graphql_name="certificationNote") + """Notes related to this database being marked as certified""" + + certifier = sgqlc.types.Field("TableauUser", graphql_name="certifier") + """User who marked this database as certified""" + + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type shortname""" + + contact = sgqlc.types.Field("TableauUser", graphql_name="contact") + """Contact for this database""" + + data_quality_certifications = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DataQualityCertification")) + ), + graphql_name="dataQualityCertifications", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityCertification_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityCertificationSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality certifications on a database + + Arguments: + + * `filter` (`DataQualityCertification_Filter`): Filter by GraphQL + field and given value + * `order_by` (`DataQualityCertificationSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_quality_certifications_connection = sgqlc.types.Field( + "DataQualityCertificationsConnection", + graphql_name="dataQualityCertificationsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityCertification_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityCertificationSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality certifications on a database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityCertification_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityCertificationSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_quality_warning = sgqlc.types.Field( + "DataQualityWarning", graphql_name="dataQualityWarning" + ) + """The optional data quality warning on a database""" + + data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DataQualityWarning")) + ), + graphql_name="dataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality warnings on a database + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_quality_warnings_connection = sgqlc.types.Field( + "DataQualityWarningsConnection", + graphql_name="dataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality warnings on a database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + description = sgqlc.types.Field(String, graphql_name="description") + """User modifiable description of this database""" + + downstream_dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Dashboard"))), + graphql_name="downstreamDashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards connected to the database + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards_connection = sgqlc.types.Field( + "DashboardsConnection", + graphql_name="downstreamDashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards connected to the database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Database"))), + graphql_name="downstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases downstream of this database + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="downstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases downstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="downstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Published datasources connected to the database + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="downstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Published datasources connected to the database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="downstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream of this database + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="downstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Lens"))), + graphql_name="downstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses connected to the database + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses_connection = sgqlc.types.Field( + "LensesConnection", + graphql_name="downstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses connected to the database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of("MetricDefinition")), + graphql_name="downstreamMetricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this database. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions_connection = sgqlc.types.Field( + "MetricDefinitionsConnection", + graphql_name="downstreamMetricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this database. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Metric"))), + graphql_name="downstreamMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics connected to the database + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics_connection = sgqlc.types.Field( + "MetricsConnection", + graphql_name="downstreamMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics connected to the database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_owners = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TableauUser"))), + graphql_name="downstreamOwners", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners connected to the database + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_owners_connection = sgqlc.types.Field( + "TableauUsersConnection", + graphql_name="downstreamOwnersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners connected to the database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Sheet"))), + graphql_name="downstreamSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets connected to the database + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="downstreamSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets connected to the database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="downstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables downstream of this database + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="downstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables downstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="downstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream of this database + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="downstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="downstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream of this database + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="downstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Workbook"))), + graphql_name="downstreamWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks connected to the database + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks_connection = sgqlc.types.Field( + "WorkbooksConnection", + graphql_name="downstreamWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks connected to the database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + has_active_warning = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="hasActiveWarning" + ) + """True if the database has an active data quality warning""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the Metadata API. Not the same as the + numeric ID used on server + """ + + is_certified = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="isCertified" + ) + """True if this database contains an active data quality + certification + """ + + is_controlled_permissions_enabled = sgqlc.types.Field( + Boolean, graphql_name="isControlledPermissionsEnabled" + ) + """True if this database has its permission locked""" + + is_embedded = sgqlc.types.Field(Boolean, graphql_name="isEmbedded") + """True if this database is embedded in Tableau content, e.g., a + packaged workbook + """ + + is_grouped = sgqlc.types.Field(Boolean, graphql_name="isGrouped") + """True if this database has been grouped with other databases""" + + labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Label"))), + graphql_name="labels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The labels on a database. Available in Tableau Cloud March 2023 / + Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + labels_connection = sgqlc.types.Field( + "LabelsConnection", + graphql_name="labelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The labels on a database. Available in Tableau Cloud March 2023 / + Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + project_vizportal_url_id = sgqlc.types.Field( + String, graphql_name="projectVizportalUrlId" + ) + """The ID of the project in which the database is visible. Will be + empty if the database is not in a project. + """ + + referenced_by_queries = sgqlc.types.Field( + sgqlc.types.list_of("CustomSQLTable"), + graphql_name="referencedByQueries", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CustomSQLTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CustomSQLTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The custom SQL queries that reference this database + + Arguments: + + * `filter` (`CustomSQLTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CustomSQLTableSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_queries_connection = sgqlc.types.Field( + "CustomSQLTablesConnection", + graphql_name="referencedByQueriesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CustomSQLTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CustomSQLTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The custom SQL queries that reference this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CustomSQLTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CustomSQLTableSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + tables = sgqlc.types.Field( + sgqlc.types.list_of("DatabaseTable"), + graphql_name="tables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables belonging to this database + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="tablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables belonging to this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + tags = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Tag"))), + graphql_name="tags", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Tag_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg(TagSortOrder, graphql_name="orderBy", default=None), + ), + ) + ), + ) + """Tags associated with the database + + Arguments: + + * `filter` (`Tag_Filter`): Filter by GraphQL field and given value + * `order_by` (`TagSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + """ + + tags_connection = sgqlc.types.Field( + "TagsConnection", + graphql_name="tagsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Tag_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg(TagSortOrder, graphql_name="orderBy", default=None), + ), + ) + ), + ) + """Tags associated with the database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Tag_Filter`): Filter by GraphQL field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TagSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + """ + + upstream_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DataQualityWarning")) + ), + graphql_name="upstreamDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this database + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings_connection = sgqlc.types.Field( + "DataQualityWarningsConnection", + graphql_name="upstreamDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Database"))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream of this database + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream of this database + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream of this database + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Label"))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this database. Available in Tableau Cloud + March 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + "LabelsConnection", + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this database. Available in Tableau Cloud + March 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream of this database + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream of this database + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="upstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream of this database + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="upstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream of this database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + vizportal_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalId" + ) + """Vizportal ID of this database, for use in client-to-server + communications + """ + + +class Datasource(sgqlc.types.Interface): + """Root GraphQL type for embedded and published data sources Data + sources are a way to represent how Tableau Desktop and Tableau + Server model and connect to data. Data sources can be published + separately, as a published data source, or may be contained in a + workbook as an embedded data source. See + https://onlinehelp.tableau.com/current/server/en-us/datasource.htm + """ + + __schema__ = tableau_schema + __field_names__ = ( + "contains_unsupported_custom_sql", + "created_at", + "datasource_filters", + "datasource_filters_connection", + "downstream_dashboards", + "downstream_dashboards_connection", + "downstream_owners", + "downstream_owners_connection", + "downstream_sheets", + "downstream_sheets_connection", + "downstream_workbooks", + "downstream_workbooks_connection", + "extract_last_incremental_update_time", + "extract_last_refresh_time", + "extract_last_update_time", + "fields", + "fields_connection", + "has_extracts", + "has_user_reference", + "id", + "lenses", + "lenses_connection", + "name", + "updated_at", + "upstream_databases", + "upstream_databases_connection", + "upstream_tables", + "upstream_tables_connection", + ) + contains_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="containsUnsupportedCustomSql" + ) + """True if the datasource contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt") + """Time the datasource was created. Available in Tableau Cloud June + 2022 / Server 2022.3 and later. + """ + + datasource_filters = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatasourceFilter")) + ), + graphql_name="datasourceFilters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data source filters contained in this data source + + Arguments: + + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + datasource_filters_connection = sgqlc.types.Field( + "DatasourceFiltersConnection", + graphql_name="datasourceFiltersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data source filters contained in this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Dashboard"))), + graphql_name="downstreamDashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards downstream from this data source + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards_connection = sgqlc.types.Field( + "DashboardsConnection", + graphql_name="downstreamDashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_owners = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TableauUser"))), + graphql_name="downstreamOwners", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Workbook owners downstream from this data source + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_owners_connection = sgqlc.types.Field( + "TableauUsersConnection", + graphql_name="downstreamOwnersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Workbook owners downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Sheet"))), + graphql_name="downstreamSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets downstream from this data source + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="downstreamSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Workbook"))), + graphql_name="downstreamWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks downstream from this data source + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks_connection = sgqlc.types.Field( + "WorkbooksConnection", + graphql_name="downstreamWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + extract_last_incremental_update_time = sgqlc.types.Field( + DateTime, graphql_name="extractLastIncrementalUpdateTime" + ) + """Time an extract was last incrementally updated""" + + extract_last_refresh_time = sgqlc.types.Field( + DateTime, graphql_name="extractLastRefreshTime" + ) + """Time an extract was last fully refreshed""" + + extract_last_update_time = sgqlc.types.Field( + DateTime, graphql_name="extractLastUpdateTime" + ) + """Time an extract was last updated by either a full refresh, + incremental update, or creation + """ + + fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Field"))), + graphql_name="fields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields usable in workbooks connected to this data source + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + fields_connection = sgqlc.types.Field( + "FieldsConnection", + graphql_name="fieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields usable in workbooks connected to this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + has_extracts = sgqlc.types.Field(Boolean, graphql_name="hasExtracts") + """True if datasource contains extracted data""" + + has_user_reference = sgqlc.types.Field(Boolean, graphql_name="hasUserReference") + """True if data source contains a formula that involves a user + function (for example, USERNAME or ISMEMBEROF) + """ + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + lenses = sgqlc.types.Field( + sgqlc.types.list_of("Lens"), + graphql_name="lenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The lenses derived from this datasource + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + lenses_connection = sgqlc.types.Field( + "LensesConnection", + graphql_name="lensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The lenses derived from this datasource + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt") + """Time the datasource was last updated. Available in Tableau Cloud + June 2022 / Server 2022.3 and later. + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream from this data source + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream from this data source + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class Field(sgqlc.types.Interface): + """Base GraphQL type for a field""" + + __schema__ = tableau_schema + __field_names__ = ( + "datasource", + "derived_lens_fields", + "derived_lens_fields_connection", + "description", + "description_inherited", + "direct_sheets", + "direct_sheets_connection", + "downstream_columns", + "downstream_columns_connection", + "downstream_dashboards", + "downstream_dashboards_connection", + "downstream_databases", + "downstream_databases_connection", + "downstream_datasources", + "downstream_datasources_connection", + "downstream_fields", + "downstream_fields_connection", + "downstream_flows", + "downstream_flows_connection", + "downstream_lenses", + "downstream_lenses_connection", + "downstream_metric_definitions", + "downstream_metric_definitions_connection", + "downstream_metrics", + "downstream_metrics_connection", + "downstream_owners", + "downstream_owners_connection", + "downstream_sheets", + "downstream_sheets_connection", + "downstream_tables", + "downstream_tables_connection", + "downstream_virtual_connection_tables", + "downstream_virtual_connection_tables_connection", + "downstream_virtual_connections", + "downstream_virtual_connections_connection", + "downstream_workbooks", + "downstream_workbooks_connection", + "folder_name", + "fully_qualified_name", + "id", + "is_hidden", + "metric_definitions", + "metric_definitions_connection", + "name", + "referenced_by_bins", + "referenced_by_bins_connection", + "referenced_by_calculations", + "referenced_by_calculations_connection", + "referenced_by_combined_fields", + "referenced_by_combined_fields_connection", + "referenced_by_combined_sets", + "referenced_by_combined_sets_connection", + "referenced_by_fields", + "referenced_by_fields_connection", + "referenced_by_filters", + "referenced_by_filters_connection", + "referenced_by_flow_field_input_field", + "referenced_by_flow_field_input_field_connection", + "referenced_by_flow_field_output_field", + "referenced_by_flow_field_output_field_connection", + "referenced_by_groups", + "referenced_by_groups_connection", + "referenced_by_hierarchies", + "referenced_by_hierarchies_connection", + "referenced_by_remote_fields", + "referenced_by_remote_fields_connection", + "referenced_by_sets", + "referenced_by_sets_connection", + "sheets", + "sheets_connection", + "upstream_columns", + "upstream_columns_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_fields", + "upstream_fields_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "upstream_virtual_connections", + "upstream_virtual_connections_connection", + ) + datasource = sgqlc.types.Field(Datasource, graphql_name="datasource") + """Data source that contains this field""" + + derived_lens_fields = sgqlc.types.Field( + sgqlc.types.list_of("LensField"), + graphql_name="derivedLensFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of lens fields which are derived from this field + + Arguments: + + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + derived_lens_fields_connection = sgqlc.types.Field( + "LensFieldsConnection", + graphql_name="derivedLensFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of lens fields which are derived from this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + description = sgqlc.types.Field(String, graphql_name="description") + """Description of field shown in server and desktop clients""" + + description_inherited = sgqlc.types.Field( + sgqlc.types.list_of("InheritedStringResult"), + graphql_name="descriptionInherited", + args=sgqlc.types.ArgDict( + ( + ( + "inheritance_type", + sgqlc.types.Arg( + InheritanceType, graphql_name="inheritanceType", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, graphql_name="permissionMode", default=None + ), + ), + ) + ), + ) + """description that is shown in the Tableau UI + + Arguments: + + * `inheritance_type` (`InheritanceType`): Method for selecting + inherited value + * `permission_mode` (`PermissionMode`): Option to select how to + apply permissions. By default it is OBFUSCATE_RESULTS + """ + + direct_sheets = sgqlc.types.Field( + sgqlc.types.list_of("Sheet"), + graphql_name="directSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this field + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + direct_sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="directSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_columns = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Column"))), + graphql_name="downstreamColumns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Columns downstream of this field + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_columns_connection = sgqlc.types.Field( + "ColumnsConnection", + graphql_name="downstreamColumnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Columns downstream of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Dashboard"))), + graphql_name="downstreamDashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards connected downstream from the field + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards_connection = sgqlc.types.Field( + "DashboardsConnection", + graphql_name="downstreamDashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards connected downstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="downstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases downstream of this field + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="downstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases downstream of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")), + graphql_name="downstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources connected downstream from this field + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="downstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources connected downstream from this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Field"))), + graphql_name="downstreamFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Downstream fields that reference this field + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_fields_connection = sgqlc.types.Field( + "FieldsConnection", + graphql_name="downstreamFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Downstream fields that reference this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="downstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream of this field + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="downstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null("Lens")), + graphql_name="downstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses connected downstream from this field + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses_connection = sgqlc.types.Field( + "LensesConnection", + graphql_name="downstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses connected downstream from this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions = sgqlc.types.Field( + sgqlc.types.list_of("MetricDefinition"), + graphql_name="downstreamMetricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this field. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions_connection = sgqlc.types.Field( + "MetricDefinitionsConnection", + graphql_name="downstreamMetricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this field. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null("Metric")), + graphql_name="downstreamMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics connected downstream from the field + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics_connection = sgqlc.types.Field( + "MetricsConnection", + graphql_name="downstreamMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics connected downstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_owners = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null("TableauUser")), + graphql_name="downstreamOwners", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Workbook owners (authors) connected downstream from the field + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_owners_connection = sgqlc.types.Field( + "TableauUsersConnection", + graphql_name="downstreamOwnersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Workbook owners (authors) connected downstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Sheet"))), + graphql_name="downstreamSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets connected downstream from the field + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="downstreamSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets connected downstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="downstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables downstream of this field + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="downstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables downstream of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="downstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream of this field + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="downstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="downstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections downstream of this field + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="downstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections downstream of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null("Workbook")), + graphql_name="downstreamWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks connected downstream from the field + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks_connection = sgqlc.types.Field( + "WorkbooksConnection", + graphql_name="downstreamWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks connected downstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + folder_name = sgqlc.types.Field(String, graphql_name="folderName") + """Name of folder if the field is in a folder. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/datafields_dwfeatures.html#Organize + """ + + fully_qualified_name = sgqlc.types.Field(String, graphql_name="fullyQualifiedName") + """Name internally used to uniquely identify fields""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_hidden = sgqlc.types.Field(Boolean, graphql_name="isHidden") + """True if the field is hidden""" + + metric_definitions = sgqlc.types.Field( + sgqlc.types.list_of("MetricDefinition"), + graphql_name="metricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions that reference this data source field. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metric_definitions_connection = sgqlc.types.Field( + "MetricDefinitionsConnection", + graphql_name="metricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions that reference this data source field. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server""" + + referenced_by_bins = sgqlc.types.Field( + sgqlc.types.list_of("BinField"), + graphql_name="referencedByBins", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The bin field that references this field + + Arguments: + + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_bins_connection = sgqlc.types.Field( + "BinFieldsConnection", + graphql_name="referencedByBinsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The bin field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_calculations = sgqlc.types.Field( + sgqlc.types.list_of("CalculatedField"), + graphql_name="referencedByCalculations", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The calculated field that references this field + + Arguments: + + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_calculations_connection = sgqlc.types.Field( + "CalculatedFieldsConnection", + graphql_name="referencedByCalculationsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The calculated field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_fields = sgqlc.types.Field( + sgqlc.types.list_of("CombinedField"), + graphql_name="referencedByCombinedFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CombinedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CombinedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The combined field that references this field + + Arguments: + + * `filter` (`CombinedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CombinedFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_fields_connection = sgqlc.types.Field( + "CombinedFieldsConnection", + graphql_name="referencedByCombinedFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CombinedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CombinedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The combined field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CombinedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CombinedFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_sets = sgqlc.types.Field( + sgqlc.types.list_of("CombinedSetField"), + graphql_name="referencedByCombinedSets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CombinedSetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CombinedSetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Thie combined set field that references this field + + Arguments: + + * `filter` (`CombinedSetField_Filter`): Filter by GraphQL field + and given value + * `order_by` (`CombinedSetFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_sets_connection = sgqlc.types.Field( + "CombinedSetFieldsConnection", + graphql_name="referencedByCombinedSetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CombinedSetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CombinedSetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Thie combined set field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CombinedSetField_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CombinedSetFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_fields = sgqlc.types.Field( + sgqlc.types.list_of("FieldReferencingField"), + graphql_name="referencedByFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FieldReferencingField_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldReferencingFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this field + + Arguments: + + * `filter` (`FieldReferencingField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FieldReferencingFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_fields_connection = sgqlc.types.Field( + "FieldReferencingFieldsConnection", + graphql_name="referencedByFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FieldReferencingField_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldReferencingFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FieldReferencingField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldReferencingFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_filters = sgqlc.types.Field( + sgqlc.types.list_of("DatasourceFilter"), + graphql_name="referencedByFilters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data source filters that include this field + + Arguments: + + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_filters_connection = sgqlc.types.Field( + "DatasourceFiltersConnection", + graphql_name="referencedByFiltersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data source filters that include this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_field_input_field = sgqlc.types.Field( + sgqlc.types.list_of("FlowFieldInputField"), + graphql_name="referencedByFlowFieldInputField", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldInputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """A flow input field that wraps this field + + Arguments: + + * `filter` (`FlowFieldInputField_Filter`): Filter by GraphQL field + and given value + * `order_by` (`FlowFieldInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + referenced_by_flow_field_input_field_connection = sgqlc.types.Field( + "FlowFieldInputFieldsConnection", + graphql_name="referencedByFlowFieldInputFieldConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldInputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """A flow input field that wraps this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldInputField_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + referenced_by_flow_field_output_field = sgqlc.types.Field( + sgqlc.types.list_of("FlowFieldOutputField"), + graphql_name="referencedByFlowFieldOutputField", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow output field that wraps this field + + Arguments: + + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_field_output_field_connection = sgqlc.types.Field( + "FlowFieldOutputFieldsConnection", + graphql_name="referencedByFlowFieldOutputFieldConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow output field that wraps this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_groups = sgqlc.types.Field( + sgqlc.types.list_of("GroupField"), + graphql_name="referencedByGroups", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + GroupField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + GroupFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The group field that references this field + + Arguments: + + * `filter` (`GroupField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`GroupFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_groups_connection = sgqlc.types.Field( + "GroupFieldsConnection", + graphql_name="referencedByGroupsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + GroupField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + GroupFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The group field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`GroupField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`GroupFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_hierarchies = sgqlc.types.Field( + sgqlc.types.list_of("HierarchyField"), + graphql_name="referencedByHierarchies", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + HierarchyField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + HierarchyFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The hierarchy field that references this field + + Arguments: + + * `filter` (`HierarchyField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`HierarchyFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_hierarchies_connection = sgqlc.types.Field( + "HierarchyFieldsConnection", + graphql_name="referencedByHierarchiesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + HierarchyField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + HierarchyFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The hierarchy field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`HierarchyField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`HierarchyFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_remote_fields = sgqlc.types.Field( + sgqlc.types.list_of("DatasourceField"), + graphql_name="referencedByRemoteFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this remote field + + Arguments: + + * `filter` (`DatasourceField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatasourceFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_remote_fields_connection = sgqlc.types.Field( + "DatasourceFieldsConnection", + graphql_name="referencedByRemoteFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this remote field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_sets = sgqlc.types.Field( + sgqlc.types.list_of("SetField"), + graphql_name="referencedBySets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The set field that this field references + + Arguments: + + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_sets_connection = sgqlc.types.Field( + "SetFieldsConnection", + graphql_name="referencedBySetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The set field that this field references + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets = sgqlc.types.Field( + sgqlc.types.list_of("Sheet"), + graphql_name="sheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this data source field + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="sheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this data source field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_columns = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of("Column")), + graphql_name="upstreamColumns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """All upstream columns this field references + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_columns_connection = sgqlc.types.Field( + "ColumnsConnection", + graphql_name="upstreamColumnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """All upstream columns this field references + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases connected upstream from the field + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases connected upstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream of this field + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of("Field")), + graphql_name="upstreamFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """fields that are upstream of this field + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields_connection = sgqlc.types.Field( + "FieldsConnection", + graphql_name="upstreamFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """fields that are upstream of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows connected upstream from the field + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows connected upstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables connected upstream from the field + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables connected upstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream of this field + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="upstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections upstream of this field + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="upstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections upstream of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class FieldReferencingField(sgqlc.types.Interface): + """Base GraphQL type for a field that references another field. For + example, a CalculatedField can reference a ColumnField in its + formula. + """ + + __schema__ = tableau_schema + __field_names__ = ( + "datasource", + "derived_lens_fields", + "derived_lens_fields_connection", + "direct_sheets", + "direct_sheets_connection", + "fields", + "fields_connection", + "fully_qualified_name", + "id", + "metric_definitions", + "metric_definitions_connection", + "referenced_by_bins", + "referenced_by_bins_connection", + "referenced_by_calculations", + "referenced_by_calculations_connection", + "referenced_by_combined_fields", + "referenced_by_combined_fields_connection", + "referenced_by_combined_sets", + "referenced_by_combined_sets_connection", + "referenced_by_fields", + "referenced_by_fields_connection", + "referenced_by_filters", + "referenced_by_filters_connection", + "referenced_by_flow_field_input_field", + "referenced_by_flow_field_input_field_connection", + "referenced_by_flow_field_output_field", + "referenced_by_flow_field_output_field_connection", + "referenced_by_groups", + "referenced_by_groups_connection", + "referenced_by_hierarchies", + "referenced_by_hierarchies_connection", + "referenced_by_remote_fields", + "referenced_by_remote_fields_connection", + "referenced_by_sets", + "referenced_by_sets_connection", + "sheets", + "sheets_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_tables", + "upstream_tables_connection", + ) + datasource = sgqlc.types.Field(Datasource, graphql_name="datasource") + """Data source that contains this field""" + + derived_lens_fields = sgqlc.types.Field( + sgqlc.types.list_of("LensField"), + graphql_name="derivedLensFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of lens fields which are derived from this field + + Arguments: + + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + derived_lens_fields_connection = sgqlc.types.Field( + "LensFieldsConnection", + graphql_name="derivedLensFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of lens fields which are derived from this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + direct_sheets = sgqlc.types.Field( + sgqlc.types.list_of("Sheet"), + graphql_name="directSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this field + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + direct_sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="directSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Field))), + graphql_name="fields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields referenced by this field + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + fields_connection = sgqlc.types.Field( + "FieldsConnection", + graphql_name="fieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields referenced by this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + fully_qualified_name = sgqlc.types.Field(String, graphql_name="fullyQualifiedName") + """Name internally used to uniquely identify fields""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + metric_definitions = sgqlc.types.Field( + sgqlc.types.list_of("MetricDefinition"), + graphql_name="metricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions that reference this data source field. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metric_definitions_connection = sgqlc.types.Field( + "MetricDefinitionsConnection", + graphql_name="metricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions that reference this data source field. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_bins = sgqlc.types.Field( + sgqlc.types.list_of("BinField"), + graphql_name="referencedByBins", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The bin field that references this field + + Arguments: + + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_bins_connection = sgqlc.types.Field( + "BinFieldsConnection", + graphql_name="referencedByBinsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The bin field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_calculations = sgqlc.types.Field( + sgqlc.types.list_of("CalculatedField"), + graphql_name="referencedByCalculations", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The calculated field that references this field + + Arguments: + + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_calculations_connection = sgqlc.types.Field( + "CalculatedFieldsConnection", + graphql_name="referencedByCalculationsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The calculated field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_fields = sgqlc.types.Field( + sgqlc.types.list_of("CombinedField"), + graphql_name="referencedByCombinedFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CombinedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CombinedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The combined field that references this field + + Arguments: + + * `filter` (`CombinedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CombinedFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_fields_connection = sgqlc.types.Field( + "CombinedFieldsConnection", + graphql_name="referencedByCombinedFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CombinedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CombinedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The combined field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CombinedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CombinedFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_sets = sgqlc.types.Field( + sgqlc.types.list_of("CombinedSetField"), + graphql_name="referencedByCombinedSets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CombinedSetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CombinedSetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Thie combined set field that references this field + + Arguments: + + * `filter` (`CombinedSetField_Filter`): Filter by GraphQL field + and given value + * `order_by` (`CombinedSetFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_combined_sets_connection = sgqlc.types.Field( + "CombinedSetFieldsConnection", + graphql_name="referencedByCombinedSetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CombinedSetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CombinedSetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Thie combined set field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CombinedSetField_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CombinedSetFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_fields = sgqlc.types.Field( + sgqlc.types.list_of("FieldReferencingField"), + graphql_name="referencedByFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FieldReferencingField_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldReferencingFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this field + + Arguments: + + * `filter` (`FieldReferencingField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FieldReferencingFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_fields_connection = sgqlc.types.Field( + "FieldReferencingFieldsConnection", + graphql_name="referencedByFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FieldReferencingField_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldReferencingFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FieldReferencingField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldReferencingFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_filters = sgqlc.types.Field( + sgqlc.types.list_of("DatasourceFilter"), + graphql_name="referencedByFilters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data source filters that include this field + + Arguments: + + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_filters_connection = sgqlc.types.Field( + "DatasourceFiltersConnection", + graphql_name="referencedByFiltersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data source filters that include this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_field_input_field = sgqlc.types.Field( + sgqlc.types.list_of("FlowFieldInputField"), + graphql_name="referencedByFlowFieldInputField", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldInputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """A flow input field that wraps this field + + Arguments: + + * `filter` (`FlowFieldInputField_Filter`): Filter by GraphQL field + and given value + * `order_by` (`FlowFieldInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + referenced_by_flow_field_input_field_connection = sgqlc.types.Field( + "FlowFieldInputFieldsConnection", + graphql_name="referencedByFlowFieldInputFieldConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldInputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """A flow input field that wraps this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldInputField_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + referenced_by_flow_field_output_field = sgqlc.types.Field( + sgqlc.types.list_of("FlowFieldOutputField"), + graphql_name="referencedByFlowFieldOutputField", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow output field that wraps this field + + Arguments: + + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_field_output_field_connection = sgqlc.types.Field( + "FlowFieldOutputFieldsConnection", + graphql_name="referencedByFlowFieldOutputFieldConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow output field that wraps this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_groups = sgqlc.types.Field( + sgqlc.types.list_of("GroupField"), + graphql_name="referencedByGroups", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + GroupField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + GroupFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The group field that references this field + + Arguments: + + * `filter` (`GroupField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`GroupFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_groups_connection = sgqlc.types.Field( + "GroupFieldsConnection", + graphql_name="referencedByGroupsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + GroupField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + GroupFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The group field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`GroupField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`GroupFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_hierarchies = sgqlc.types.Field( + sgqlc.types.list_of("HierarchyField"), + graphql_name="referencedByHierarchies", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + HierarchyField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + HierarchyFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The hierarchy field that references this field + + Arguments: + + * `filter` (`HierarchyField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`HierarchyFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_hierarchies_connection = sgqlc.types.Field( + "HierarchyFieldsConnection", + graphql_name="referencedByHierarchiesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + HierarchyField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + HierarchyFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The hierarchy field that references this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`HierarchyField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`HierarchyFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_remote_fields = sgqlc.types.Field( + sgqlc.types.list_of("DatasourceField"), + graphql_name="referencedByRemoteFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this remote field + + Arguments: + + * `filter` (`DatasourceField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatasourceFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_remote_fields_connection = sgqlc.types.Field( + "DatasourceFieldsConnection", + graphql_name="referencedByRemoteFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The field that references this remote field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_sets = sgqlc.types.Field( + sgqlc.types.list_of("SetField"), + graphql_name="referencedBySets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The set field that this field references + + Arguments: + + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_sets_connection = sgqlc.types.Field( + "SetFieldsConnection", + graphql_name="referencedBySetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The set field that this field references + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets = sgqlc.types.Field( + sgqlc.types.list_of("Sheet"), + graphql_name="sheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this data source field + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="sheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that reference this data source field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases connected upstream from the field + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases connected upstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows connected upstream from the field + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows connected upstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables connected upstream from the field + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables connected upstream from the field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class FlowInputField(sgqlc.types.Interface): + """A wrapper for an input field contained in a published flow.""" + + __schema__ = tableau_schema + __field_names__ = ( + "child_fields", + "child_fields_connection", + "flow", + "id", + "name", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_tables", + "upstream_tables_connection", + ) + child_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("FlowOutputField")) + ), + graphql_name="childFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields that are children of this field + + Arguments: + + * `filter` (`FlowOutputField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`FlowOutputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + child_fields_connection = sgqlc.types.Field( + "FlowOutputFieldsConnection", + graphql_name="childFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields that are children of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowOutputField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowOutputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow = sgqlc.types.Field("Flow", graphql_name="flow") + """A flow to which these fields input""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are upstream from this inputField. + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are upstream from this inputField. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are upstream from this inputField. + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are upstream from this inputField. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are upstream from this inputField. + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are upstream from this inputField. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are upstream of this field. + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are upstream of this field. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class FlowOutputField(sgqlc.types.Interface): + """A wrapper for an output field contained in a published flow.""" + + __schema__ = tableau_schema + __field_names__ = ( + "downstream_dashboards", + "downstream_dashboards_connection", + "downstream_databases", + "downstream_databases_connection", + "downstream_datasources", + "downstream_datasources_connection", + "downstream_flows", + "downstream_flows_connection", + "downstream_lenses", + "downstream_lenses_connection", + "downstream_metric_definitions", + "downstream_metric_definitions_connection", + "downstream_metrics", + "downstream_metrics_connection", + "downstream_owners", + "downstream_owners_connection", + "downstream_sheets", + "downstream_sheets_connection", + "downstream_tables", + "downstream_tables_connection", + "downstream_virtual_connection_tables", + "downstream_virtual_connection_tables_connection", + "downstream_virtual_connections", + "downstream_virtual_connections_connection", + "downstream_workbooks", + "downstream_workbooks_connection", + "flow", + "flow_connection", + "flow_output_step", + "id", + "name", + "parent_fields", + "parent_fields_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "upstream_virtual_connections", + "upstream_virtual_connections_connection", + ) + downstream_dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Dashboard"))), + graphql_name="downstreamDashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards that are downstream from this outputField + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards_connection = sgqlc.types.Field( + "DashboardsConnection", + graphql_name="downstreamDashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards that are downstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="downstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are downstream from this outputField + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="downstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are downstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="downstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources that are downstream from this outputField + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="downstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources that are downstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="downstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are downstream from this outputField + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="downstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are downstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Lens"))), + graphql_name="downstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses that are downstream from this outputField + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses_connection = sgqlc.types.Field( + "LensesConnection", + graphql_name="downstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses that are downstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions = sgqlc.types.Field( + sgqlc.types.list_of("MetricDefinition"), + graphql_name="downstreamMetricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this flow output field. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions_connection = sgqlc.types.Field( + "MetricDefinitionsConnection", + graphql_name="downstreamMetricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this flow output field. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Metric"))), + graphql_name="downstreamMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics that are downstream from this outputField + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics_connection = sgqlc.types.Field( + "MetricsConnection", + graphql_name="downstreamMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics that are downstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_owners = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TableauUser"))), + graphql_name="downstreamOwners", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners that are downstream from this outputField + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_owners_connection = sgqlc.types.Field( + "TableauUsersConnection", + graphql_name="downstreamOwnersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners that are downstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Sheet"))), + graphql_name="downstreamSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that are downstream from this outputField + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="downstreamSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that are downstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="downstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are downstream from this outputField + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="downstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are downstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="downstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnectionTables that are downstream of this outputField + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="downstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnectionTables that are downstream of this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="downstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnections that are downstream of this outputField + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="downstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnections that are downstream of this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Workbook"))), + graphql_name="downstreamWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks that are downstream from this outputField + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks_connection = sgqlc.types.Field( + "WorkbooksConnection", + graphql_name="downstreamWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks that are downstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow = sgqlc.types.Field( + sgqlc.types.list_of("Flow"), + graphql_name="flow", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flow that outputs these fields + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="flowConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flow that outputs these fields + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow_output_step = sgqlc.types.Field( + "FlowOutputStep", graphql_name="flowOutputStep" + ) + """The flow output step that contains this field""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + parent_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FlowInputField))), + graphql_name="parentFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowInputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowInputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields that are parents of this field + + Arguments: + + * `filter` (`FlowInputField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`FlowInputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parent_fields_connection = sgqlc.types.Field( + "FlowInputFieldsConnection", + graphql_name="parentFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowInputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowInputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields that are parents of this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowInputField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowInputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are upstream from this outputField + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are upstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources that are upstream from this outputField + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources that are upstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are upstream from this outputField. + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are upstream from this outputField. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are upstream from this outputField + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are upstream from this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnectionTables that are upstream of this outputField + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnectionTables that are upstream of this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="upstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnections that are upstream of this outputField + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="upstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnections that are upstream of this outputField + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class Label(sgqlc.types.Interface): + """A label that can be attached to assets. *Available in Tableau + Cloud March 2023 / Server 2023.1 and later.* + """ + + __schema__ = tableau_schema + __field_names__ = ( + "asset", + "author", + "author_display_name", + "category", + "created_at", + "id", + "is_active", + "is_elevated", + "luid", + "message", + "updated_at", + "value", + "vizportal_id", + ) + asset = sgqlc.types.Field(CanHaveLabels, graphql_name="asset") + """The asset that contains the label""" + + author = sgqlc.types.Field("TableauUser", graphql_name="author") + """User who last updated this label""" + + author_display_name = sgqlc.types.Field(String, graphql_name="authorDisplayName") + """Name of the user who last updated this label""" + + category = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="category") + """Category of the label""" + + created_at = sgqlc.types.Field( + sgqlc.types.non_null(DateTime), graphql_name="createdAt" + ) + """Time the label was created""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_active = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="isActive" + ) + """True if the label is active""" + + is_elevated = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="isElevated" + ) + """True if the label is elevated""" + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """Message of the label""" + + updated_at = sgqlc.types.Field( + sgqlc.types.non_null(DateTime), graphql_name="updatedAt" + ) + """Time the label was last updated""" + + value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value") + """Value of the label""" + + vizportal_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalId" + ) + """Vizportal ID of this label, for use in client-to-server + communications + """ + + +class Node(sgqlc.types.Interface): + """Inheritance target""" + + __schema__ = tableau_schema + __field_names__ = ("id",) + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + +class Table(sgqlc.types.Interface): + """A table containing columns""" + + __schema__ = tableau_schema + __field_names__ = ( + "columns", + "columns_connection", + "description", + "downstream_dashboards", + "downstream_dashboards_connection", + "downstream_databases", + "downstream_databases_connection", + "downstream_datasources", + "downstream_datasources_connection", + "downstream_flows", + "downstream_flows_connection", + "downstream_lenses", + "downstream_lenses_connection", + "downstream_metrics", + "downstream_metrics_connection", + "downstream_owners", + "downstream_owners_connection", + "downstream_sheets", + "downstream_sheets_connection", + "downstream_tables", + "downstream_tables_connection", + "downstream_virtual_connection_tables", + "downstream_virtual_connection_tables_connection", + "downstream_virtual_connections", + "downstream_virtual_connections_connection", + "downstream_workbooks", + "downstream_workbooks_connection", + "id", + "is_embedded", + "name", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "upstream_virtual_connections", + "upstream_virtual_connections_connection", + ) + columns = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Column"))), + graphql_name="columns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Columns contained in this table + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + columns_connection = sgqlc.types.Field( + "ColumnsConnection", + graphql_name="columnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Columns contained in this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + description = sgqlc.types.Field(String, graphql_name="description") + """User modifiable description of this table""" + + downstream_dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Dashboard"))), + graphql_name="downstreamDashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards connected to the table + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards_connection = sgqlc.types.Field( + "DashboardsConnection", + graphql_name="downstreamDashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards connected to the table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="downstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases downstream of this table + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="downstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases downstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="downstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Published datasources connected to the table + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="downstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Published datasources connected to the table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="downstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream of this table + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="downstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Lens"))), + graphql_name="downstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses connected downstream from the table + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses_connection = sgqlc.types.Field( + "LensesConnection", + graphql_name="downstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses connected downstream from the table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Metric"))), + graphql_name="downstreamMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics connected to the table + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics_connection = sgqlc.types.Field( + "MetricsConnection", + graphql_name="downstreamMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics connected to the table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_owners = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TableauUser"))), + graphql_name="downstreamOwners", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners of workbooks and published datasources connected to the + table + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_owners_connection = sgqlc.types.Field( + "TableauUsersConnection", + graphql_name="downstreamOwnersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners of workbooks and published datasources connected to the + table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Sheet"))), + graphql_name="downstreamSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets connected to the table + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_sheets_connection = sgqlc.types.Field( + "SheetsConnection", + graphql_name="downstreamSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets connected to the table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="downstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables downstream of this table + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="downstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables downstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="downstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream of this table + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="downstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="downstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection downstream of this table + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="downstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection downstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Workbook"))), + graphql_name="downstreamWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks connected to the table + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks_connection = sgqlc.types.Field( + "WorkbooksConnection", + graphql_name="downstreamWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks connected to the table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + is_embedded = sgqlc.types.Field(Boolean, graphql_name="isEmbedded") + """True if this table is embedded in Tableau content, e.g., a + packaged workbook + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream of this table + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + "DatabasesConnection", + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream of this table + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream of this table + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + "FlowsConnection", + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream of this table + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + "DatabaseTablesConnection", + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream of this table + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="upstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections upstream of this table + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="upstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections upstream of this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class Taggable(sgqlc.types.Interface): + """A content item that has a list of tags""" + + __schema__ = tableau_schema + __field_names__ = ("id", "luid", "name", "tags", "tags_connection") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of the asset""" + + tags = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Tag"))), + graphql_name="tags", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Tag_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg(TagSortOrder, graphql_name="orderBy", default=None), + ), + ) + ), + ) + """Tags associated with the content item + + Arguments: + + * `filter` (`Tag_Filter`): Filter by GraphQL field and given value + * `order_by` (`TagSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + """ + + tags_connection = sgqlc.types.Field( + "TagsConnection", + graphql_name="tagsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Tag_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg(TagSortOrder, graphql_name="orderBy", default=None), + ), + ) + ), + ) + """Tags associated with the content item + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Tag_Filter`): Filter by GraphQL field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TagSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + """ + + +class View(sgqlc.types.Interface): + """A view contained in a published workbook. Views can be sheets or + dashboards. + """ + + __schema__ = tableau_schema + __field_names__ = ( + "created_at", + "document_view_id", + "id", + "index", + "luid", + "name", + "path", + "referenced_by_metrics", + "referenced_by_metrics_connection", + "tags", + "tags_connection", + "updated_at", + "upstream_data_quality_warnings", + "upstream_data_quality_warnings_connection", + "upstream_labels", + "upstream_labels_connection", + "workbook", + ) + created_at = sgqlc.types.Field( + sgqlc.types.non_null(DateTime), graphql_name="createdAt" + ) + """Time the view was created""" + + document_view_id = sgqlc.types.Field(String, graphql_name="documentViewId") + """Unique ID for the view generated for and stored within the + workbook, survives renames, and is used for internal processes + """ + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + index = sgqlc.types.Field(Int, graphql_name="index") + """Index of view; the order it appears in the workbook""" + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server (Blank if sheet is hidden in Workbook) + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + path = sgqlc.types.Field(String, graphql_name="path") + """Server path to view""" + + referenced_by_metrics = sgqlc.types.Field( + sgqlc.types.list_of("Metric"), + graphql_name="referencedByMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Metrics that reference this View + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_metrics_connection = sgqlc.types.Field( + "MetricsConnection", + graphql_name="referencedByMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Metrics that reference this View + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + tags = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Tag"))), + graphql_name="tags", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Tag_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg(TagSortOrder, graphql_name="orderBy", default=None), + ), + ) + ), + ) + """Tags associated with the view + + Arguments: + + * `filter` (`Tag_Filter`): Filter by GraphQL field and given value + * `order_by` (`TagSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + """ + + tags_connection = sgqlc.types.Field( + "TagsConnection", + graphql_name="tagsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Tag_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg(TagSortOrder, graphql_name="orderBy", default=None), + ), + ) + ), + ) + """Tags associated with the view + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Tag_Filter`): Filter by GraphQL field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TagSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + """ + + updated_at = sgqlc.types.Field( + sgqlc.types.non_null(DateTime), graphql_name="updatedAt" + ) + """Time the view was updated""" + + upstream_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DataQualityWarning")) + ), + graphql_name="upstreamDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this view + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings_connection = sgqlc.types.Field( + "DataQualityWarningsConnection", + graphql_name="upstreamDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this view + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this view. Available in Tableau Cloud March + 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + "LabelsConnection", + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this view. Available in Tableau Cloud March + 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + workbook = sgqlc.types.Field("Workbook", graphql_name="workbook") + """The workbook that contains this view""" + + +class Warnable(sgqlc.types.Interface): + """A content item that can have data quality warnings""" + + __schema__ = tableau_schema + __field_names__ = ( + "data_quality_warning", + "data_quality_warnings", + "data_quality_warnings_connection", + "has_active_warning", + "id", + "luid", + "name", + ) + data_quality_warning = sgqlc.types.Field( + "DataQualityWarning", graphql_name="dataQualityWarning" + ) + """The optional data quality warning on a content item""" + + data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DataQualityWarning")) + ), + graphql_name="dataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality warnings on a content item + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_quality_warnings_connection = sgqlc.types.Field( + "DataQualityWarningsConnection", + graphql_name="dataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality warnings on a content item + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + has_active_warning = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="hasActiveWarning" + ) + """True if the content has an active data quality warning""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of the asset""" + + +class AnalyticsFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for AnalyticsField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(AnalyticsField))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class AskDataExtension(sgqlc.types.Type): + """AskDataExtensions to base Tableau functionality.""" + + __schema__ = tableau_schema + __field_names__ = ("dashboard", "id", "lens") + dashboard = sgqlc.types.Field("Dashboard", graphql_name="dashboard") + """The dashboard that contains this askData extension""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API""" + + lens = sgqlc.types.Field("Lens", graphql_name="lens") + """Lens configured for the askData extension""" + + +class AskDataExtensionsConnection(sgqlc.types.relay.Connection): + """Connection Type for AskDataExtension""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(AskDataExtension)) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class BinFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for BinField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("BinField"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class CalculatedFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for CalculatedField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("CalculatedField")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class CanHaveLabelsesConnection(sgqlc.types.relay.Connection): + """Connection Type for CanHaveLabels""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(CanHaveLabels))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class CertifiablesConnection(sgqlc.types.relay.Connection): + """Connection Type for Certifiable""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Certifiable))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class CloudFilesConnection(sgqlc.types.relay.Connection): + """Connection Type for CloudFile""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("CloudFile"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class ColumnFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for ColumnField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("ColumnField"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class ColumnsConnection(sgqlc.types.relay.Connection): + """Connection Type for Column""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Column"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class CombinedFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for CombinedField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("CombinedField")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class CombinedSetFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for CombinedSetField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("CombinedSetField")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class CustomSQLTablesConnection(sgqlc.types.relay.Connection): + """Connection Type for CustomSQLTable""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("CustomSQLTable")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DashboardsConnection(sgqlc.types.relay.Connection): + """Connection Type for Dashboard""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Dashboard"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DataCloudsConnection(sgqlc.types.relay.Connection): + """Connection Type for DataCloud""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("DataCloud"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DataFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for DataField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(DataField))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DataQualityCertificationsConnection(sgqlc.types.relay.Connection): + """Connection Type for DataQualityCertification""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DataQualityCertification")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DataQualityWarningsConnection(sgqlc.types.relay.Connection): + """Connection Type for DataQualityWarning""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DataQualityWarning")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DatabaseServersConnection(sgqlc.types.relay.Connection): + """Connection Type for DatabaseServer""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseServer")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DatabaseTablesConnection(sgqlc.types.relay.Connection): + """Connection Type for DatabaseTable""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DatabasesConnection(sgqlc.types.relay.Connection): + """Connection Type for Database""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DatasourceFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for DatasourceField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatasourceField")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DatasourceFilter(sgqlc.types.Type): + """Data source filters include/exclude certain values from a single + field to filter out rows of data from this data source. For data + security reasons, we don't track the values used in the filter in + this schema, but you can see the field used in the filter. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/filtering_datasource.html + """ + + __schema__ = tableau_schema + __field_names__ = ("datasource", "field", "id") + datasource = sgqlc.types.Field(Datasource, graphql_name="datasource") + """Data source that contains this datasource filter""" + + field = sgqlc.types.Field(sgqlc.types.non_null(Field), graphql_name="field") + """Field used by this filter.""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + +class DatasourceFiltersConnection(sgqlc.types.relay.Connection): + """Connection Type for DatasourceFilter""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(DatasourceFilter)) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class DatasourcesConnection(sgqlc.types.relay.Connection): + """Connection Type for Datasource""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Datasource))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class EmbeddedDatasourcesConnection(sgqlc.types.relay.Connection): + """Connection Type for EmbeddedDatasource""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("EmbeddedDatasource")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FieldReferencingFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for FieldReferencingField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(FieldReferencingField)) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for Field""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Field))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FilesConnection(sgqlc.types.relay.Connection): + """Connection Type for File""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("File"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FlowColumnInputFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for FlowColumnInputField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("FlowColumnInputField")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FlowColumnOutputFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for FlowColumnOutputField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("FlowColumnOutputField")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FlowFieldInputFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for FlowFieldInputField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("FlowFieldInputField")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FlowFieldOutputFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for FlowFieldOutputField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("FlowFieldOutputField")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FlowInputFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for FlowInputField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FlowInputField))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FlowOutputFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for FlowOutputField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(FlowOutputField)) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FlowOutputStep(sgqlc.types.Type): + """A flow output step""" + + __schema__ = tableau_schema + __field_names__ = ( + "flow", + "id", + "name", + "output_fields", + "output_fields_connection", + "step_id", + ) + flow = sgqlc.types.Field("Flow", graphql_name="flow") + """The flow that contains this output step""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API""" + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server and desktop clients""" + + output_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(FlowOutputField)) + ), + graphql_name="outputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields output by this step + + Arguments: + + * `filter` (`FlowOutputField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`FlowOutputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + output_fields_connection = sgqlc.types.Field( + FlowOutputFieldsConnection, + graphql_name="outputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields output by this step + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowOutputField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowOutputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + step_id = sgqlc.types.Field(String, graphql_name="stepId") + """Identifier internal to flow""" + + +class FlowOutputStepsConnection(sgqlc.types.relay.Connection): + """Connection Type for FlowOutputStep""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FlowOutputStep))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class FlowsConnection(sgqlc.types.relay.Connection): + """Connection Type for Flow""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class GenericLabelsConnection(sgqlc.types.relay.Connection): + """Connection Type for GenericLabel""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("GenericLabel"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class GroupFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for GroupField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("GroupField"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class HierarchyFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for HierarchyField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("HierarchyField")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class InheritedStringResult(sgqlc.types.Type): + """Wrapper type containing the inherited result""" + + __schema__ = tableau_schema + __field_names__ = ("asset", "asset_id", "attribute", "distance", "edges", "value") + asset = sgqlc.types.Field(Node, graphql_name="asset") + """The object (i.e., inheritance source) where the attribute was + inherited from + """ + + asset_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="assetId") + """Unique identifier of the object (i.e., inheritance source) that is + providing the inherited attribute + """ + + attribute = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="attribute" + ) + """Name of the property that is being inherited""" + + distance = sgqlc.types.Field(Int, graphql_name="distance") + """Number of edges in between the inheritance source and inheritance + target + """ + + edges = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="edges" + ) + """The edges between inheritance source and inheritance target""" + + value = sgqlc.types.Field(String, graphql_name="value") + """Inherited value""" + + +class LabelsConnection(sgqlc.types.relay.Connection): + """Connection Type for Label""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class Lens(sgqlc.types.Type): + """Lenses are curated, embeddable Ask Data experiences. *Introduced + in Tableau Cloud June 2022 / Server 2022.3.* *Retired in Tableau + Cloud February 2024 / Server 2024.2.* + """ + + __schema__ = tableau_schema + __field_names__ = ( + "ask_data_extensions", + "ask_data_extensions_connection", + "created_at", + "datasource", + "description", + "downstream_dashboards", + "downstream_dashboards_connection", + "downstream_metrics", + "downstream_metrics_connection", + "downstream_owners", + "downstream_owners_connection", + "downstream_workbooks", + "downstream_workbooks_connection", + "fields", + "fields_connection", + "id", + "luid", + "name", + "owner", + "project_vizportal_url_id", + "site", + "updated_at", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_fields", + "upstream_fields_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "upstream_virtual_connections", + "upstream_virtual_connections_connection", + "vizportal_url_id", + ) + ask_data_extensions = sgqlc.types.Field( + sgqlc.types.list_of(AskDataExtension), + graphql_name="askDataExtensions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + AskDataExtension_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + AskDataExtensionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The lens configured in askData extension + + Arguments: + + * `filter` (`AskDataExtension_Filter`): Filter by GraphQL field + and given value + * `order_by` (`AskDataExtensionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + ask_data_extensions_connection = sgqlc.types.Field( + AskDataExtensionsConnection, + graphql_name="askDataExtensionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + AskDataExtension_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + AskDataExtensionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The lens configured in askData extension + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`AskDataExtension_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`AskDataExtensionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + created_at = sgqlc.types.Field( + sgqlc.types.non_null(DateTime), graphql_name="createdAt" + ) + """Time the Lens was created""" + + datasource = sgqlc.types.Field( + sgqlc.types.non_null(Datasource), graphql_name="datasource" + ) + """Datasource this lens is derived from""" + + description = sgqlc.types.Field(String, graphql_name="description") + """Description of the Lens""" + + downstream_dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Dashboard"))), + graphql_name="downstreamDashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """"Dashboards connected to the Lens" + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards_connection = sgqlc.types.Field( + DashboardsConnection, + graphql_name="downstreamDashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Metric"))), + graphql_name="downstreamMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """"Metrics connected to the Lens" + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics_connection = sgqlc.types.Field( + "MetricsConnection", + graphql_name="downstreamMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_owners = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TableauUser"))), + graphql_name="downstreamOwners", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners of contents connected to the Lens + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_owners_connection = sgqlc.types.Field( + "TableauUsersConnection", + graphql_name="downstreamOwnersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners of contents connected to the Lens + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_workbooks = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Workbook"))), + graphql_name="downstreamWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """"Workbooks connected to the Lens" + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks_connection = sgqlc.types.Field( + "WorkbooksConnection", + graphql_name="downstreamWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("LensField"))), + graphql_name="fields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The list of fields + + Arguments: + + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + fields_connection = sgqlc.types.Field( + "LensFieldsConnection", + graphql_name="fieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The list of fields + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name shown in server""" + + owner = sgqlc.types.Field(sgqlc.types.non_null("TableauUser"), graphql_name="owner") + """User who owns this Lens""" + + project_vizportal_url_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="projectVizportalUrlId" + ) + """The ID of the project in which the Lens is visible and usable.""" + + site = sgqlc.types.Field(sgqlc.types.non_null("TableauSite"), graphql_name="site") + """The site in which the Lens is visible and usable""" + + updated_at = sgqlc.types.Field( + sgqlc.types.non_null(DateTime), graphql_name="updatedAt" + ) + """Time the Lens was last updated""" + + upstream_databases = sgqlc.types.Field( + sgqlc.types.list_of(Database), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Databases that are upstream to this Lens + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Databases that are upstream to this Lens + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.list_of("PublishedDatasource"), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The datasource that are upstream of this lens + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The datasource that are upstream of this lens + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields = sgqlc.types.Field( + sgqlc.types.list_of(Field), + graphql_name="upstreamFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The fields that are upstream of this lens + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="upstreamFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The fields that are upstream of this lens + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.list_of("Flow"), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are upstream of this Lens + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are upstream of this Lens + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Table))), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Table_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + TableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are upstream of this Lens + + Arguments: + + * `filter` (`Table_Filter`): Filter by GraphQL field and given + value + * `order_by` (`TableSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + "TablesConnection", + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Table_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are upstream of this Lens + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Table_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.list_of("VirtualConnectionTable"), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection table upstream to this Lens + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection table upstream to this Lens + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.list_of("VirtualConnection"), + graphql_name="upstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection upstream to this Lens + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="upstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection upstream to this Lens + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + vizportal_url_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalUrlId" + ) + """VizPortal URL ID; used for URL generation""" + + +class LensField(sgqlc.types.Type): + """Lens Fields contain extra information based on an underlying + datasource field + """ + + __schema__ = tableau_schema + __field_names__ = ( + "containing_lens", + "datasource_field", + "description", + "id", + "name", + ) + containing_lens = sgqlc.types.Field(Lens, graphql_name="containingLens") + """The Lens which contains this lens field""" + + datasource_field = sgqlc.types.Field( + sgqlc.types.non_null(Field), graphql_name="datasourceField" + ) + """Underlying datasource field this lens field is based on""" + + description = sgqlc.types.Field(String, graphql_name="description") + """Description of field shown in Ask Data. If null or empty, use + description inherited from datasource field. + """ + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name of field shown locally in Ask Data. If null or empty, use + name inherited from datasource field. + """ + + +class LensFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for LensField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LensField))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class LensesConnection(sgqlc.types.relay.Connection): + """Connection Type for Lens""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Lens))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class LinkedFlow(sgqlc.types.Type): + """Wrapper type including edge information""" + + __schema__ = tableau_schema + __field_names__ = ("asset", "asset_id", "from_edges", "to_edges") + asset = sgqlc.types.Field(sgqlc.types.non_null("Flow"), graphql_name="asset") + """Object in this linked flow""" + + asset_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="assetId") + """Unique identifier of the object in this linked flow""" + + from_edges = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="fromEdges" + ) + """The nodes preceding this node""" + + to_edges = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="toEdges" + ) + """The nodes following this node""" + + +class LinkedFlowsConnection(sgqlc.types.relay.Connection): + """Connection Type for LinkedFlow""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LinkedFlow))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class MetricDefinition(sgqlc.types.Type): + """A Tableau Pulse metric definition. *Available in Tableau Cloud + June 2024 and later. Tableau Pulse is not available in Tableau + Server.* + """ + + __schema__ = tableau_schema + __field_names__ = ( + "fields", + "fields_connection", + "id", + "luid", + "name", + "site", + "upstream_columns", + "upstream_columns_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_fields", + "upstream_fields_connection", + "upstream_flow_output_fields", + "upstream_flow_output_fields_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_labels", + "upstream_labels_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "upstream_virtual_connections", + "upstream_virtual_connections_connection", + ) + fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Field))), + graphql_name="fields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields contained in the metric definition + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + fields_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="fieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields contained in the metric definition + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the Metadata API. Not the same as the + locally unique identifier used with the REST API. + """ + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server. + """ + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """Name of the metric definition.""" + + site = sgqlc.types.Field(sgqlc.types.non_null("TableauSite"), graphql_name="site") + """The site which contains the metric definition.""" + + upstream_columns = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Column"))), + graphql_name="upstreamColumns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Columns upstream from the metric definition. + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_columns_connection = sgqlc.types.Field( + ColumnsConnection, + graphql_name="upstreamColumnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Columns upstream from the metric definition. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream from the metric definition + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream from the metric definition + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data sources upstream from the metric definition. + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + "PublishedDatasourcesConnection", + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data sources upstream from the metric definition. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Field))), + graphql_name="upstreamFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields upstream from the metric definition. + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="upstreamFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields upstream from the metric definition. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flow_output_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(FlowOutputField)) + ), + graphql_name="upstreamFlowOutputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flow output fields upstream from the metric definition. + + Arguments: + + * `filter` (`FlowOutputField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`FlowOutputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flow_output_fields_connection = sgqlc.types.Field( + FlowOutputFieldsConnection, + graphql_name="upstreamFlowOutputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flow output fields upstream from the metric definition. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowOutputField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowOutputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream from the metric definition. + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream from the metric definition. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from the metric definition. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + LabelsConnection, + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from the metric definition. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream from the metric definition. + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream from the metric definition. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream from the metric definition. + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream from the metric definition. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="upstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections upstream from the metric definition. + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="upstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections upstream from the metric definition. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class MetricDefinitionsConnection(sgqlc.types.relay.Connection): + """Connection Type for MetricDefinition""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(MetricDefinition)) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class MetricsConnection(sgqlc.types.relay.Connection): + """Connection Type for Metric""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Metric"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class NodesConnection(sgqlc.types.relay.Connection): + """Connection Type for Node""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Node))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class PageInfo(sgqlc.types.Type): + """Information about pagination in a connection""" + + __schema__ = tableau_schema + __field_names__ = ("end_cursor", "has_next_page") + end_cursor = sgqlc.types.Field(String, graphql_name="endCursor") + """Cursor to use in subsequent query to fetch next page of objects""" + + has_next_page = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="hasNextPage" + ) + """Indicates if there are more objects to fetch""" + + +class Parameter(sgqlc.types.Type): + """Tableau Parameter. For more info see + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/parameters_create.html + """ + + __schema__ = tableau_schema + __field_names__ = ( + "datasource", + "id", + "name", + "parent_name", + "referenced_by_bins", + "referenced_by_bins_connection", + "referenced_by_calculations", + "referenced_by_calculations_connection", + "referenced_by_sets", + "referenced_by_sets_connection", + "workbook", + ) + datasource = sgqlc.types.Field("PublishedDatasource", graphql_name="datasource") + """Published data source that contains this parameter""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Name of parameter""" + + parent_name = sgqlc.types.Field(String, graphql_name="parentName") + """Name of the parameter's parent""" + + referenced_by_bins = sgqlc.types.Field( + sgqlc.types.list_of("BinField"), + graphql_name="referencedByBins", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The bin field that references this parameter + + Arguments: + + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_bins_connection = sgqlc.types.Field( + BinFieldsConnection, + graphql_name="referencedByBinsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The bin field that references this parameter + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_calculations = sgqlc.types.Field( + sgqlc.types.list_of("CalculatedField"), + graphql_name="referencedByCalculations", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The calculated field that references this parameter + + Arguments: + + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_calculations_connection = sgqlc.types.Field( + CalculatedFieldsConnection, + graphql_name="referencedByCalculationsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The calculated field that references this parameter + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_sets = sgqlc.types.Field( + sgqlc.types.list_of("SetField"), + graphql_name="referencedBySets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The set field that this parameter references + + Arguments: + + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_sets_connection = sgqlc.types.Field( + "SetFieldsConnection", + graphql_name="referencedBySetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The set field that this parameter references + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + workbook = sgqlc.types.Field("Workbook", graphql_name="workbook") + """Workbook that contains this parameter""" + + +class ParametersConnection(sgqlc.types.relay.Connection): + """Connection Type for Parameter""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Parameter))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class PublishedDatasourcesConnection(sgqlc.types.relay.Connection): + """Connection Type for PublishedDatasource""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class Query(sgqlc.types.Type): + """Query root for Metadata GraphQL interface""" + + __schema__ = tableau_schema + __field_names__ = ( + "ask_data_extensions", + "ask_data_extensions_connection", + "bin_fields", + "bin_fields_connection", + "calculated_fields", + "calculated_fields_connection", + "cloud_files", + "cloud_files_connection", + "column_fields", + "column_fields_connection", + "columns", + "columns_connection", + "combined_fields", + "combined_fields_connection", + "combined_set_fields", + "combined_set_fields_connection", + "custom_sqltables", + "custom_sqltables_connection", + "dashboards", + "dashboards_connection", + "data_clouds", + "data_clouds_connection", + "data_quality_certifications", + "data_quality_certifications_connection", + "data_quality_warnings", + "data_quality_warnings_connection", + "database_servers", + "database_servers_connection", + "database_tables", + "database_tables_connection", + "databases", + "databases_connection", + "datasource_fields", + "datasource_fields_connection", + "datasource_filters", + "datasource_filters_connection", + "datasources", + "datasources_connection", + "embedded_datasources", + "embedded_datasources_connection", + "fields", + "fields_connection", + "files", + "files_connection", + "flow_column_input_fields", + "flow_column_input_fields_connection", + "flow_column_output_fields", + "flow_column_output_fields_connection", + "flow_field_input_fields", + "flow_field_input_fields_connection", + "flow_field_output_fields", + "flow_field_output_fields_connection", + "flow_output_steps", + "flow_output_steps_connection", + "flows", + "flows_connection", + "generic_labels", + "generic_labels_connection", + "group_fields", + "group_fields_connection", + "hierarchy_fields", + "hierarchy_fields_connection", + "lens_fields", + "lens_fields_connection", + "lenses", + "lenses_connection", + "metric_definitions", + "metric_definitions_connection", + "metrics", + "metrics_connection", + "parameters", + "parameters_connection", + "published_datasources", + "published_datasources_connection", + "set_fields", + "set_fields_connection", + "sheets", + "sheets_connection", + "table_additional_detailses", + "table_additional_detailses_connection", + "tableau_sites", + "tableau_sites_connection", + "tableau_users", + "tableau_users_connection", + "tables", + "tables_connection", + "tags", + "tags_connection", + "views", + "views_connection", + "virtual_connection_tables", + "virtual_connection_tables_connection", + "virtual_connections", + "virtual_connections_connection", + "web_data_connectors", + "web_data_connectors_connection", + "workbooks", + "workbooks_connection", + ) + ask_data_extensions = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(AskDataExtension)) + ), + graphql_name="askDataExtensions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + AskDataExtension_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + AskDataExtensionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches AskDataExtensions by filtering on id or name + + Arguments: + + * `filter` (`AskDataExtension_Filter`): Filter by GraphQL field + and given value + * `order_by` (`AskDataExtensionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + ask_data_extensions_connection = sgqlc.types.Field( + sgqlc.types.non_null(AskDataExtensionsConnection), + graphql_name="askDataExtensionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + AskDataExtension_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + AskDataExtensionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch AskDataExtensions with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`AskDataExtension_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`AskDataExtensionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + bin_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("BinField"))), + graphql_name="binFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches BinFields by filtering on id or name + + Arguments: + + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + bin_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(BinFieldsConnection), + graphql_name="binFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + BinField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + BinFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch BinFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`BinField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`BinFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + calculated_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("CalculatedField")) + ), + graphql_name="calculatedFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches CalculatedFields by filtering on id or name + + Arguments: + + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + calculated_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(CalculatedFieldsConnection), + graphql_name="calculatedFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch CalculatedFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + cloud_files = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("CloudFile"))), + graphql_name="cloudFiles", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CloudFile_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CloudFileSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches CloudFiles by filtering on id or name + + Arguments: + + * `filter` (`CloudFile_Filter`): Filter by GraphQL field and given + value + * `order_by` (`CloudFileSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + cloud_files_connection = sgqlc.types.Field( + sgqlc.types.non_null(CloudFilesConnection), + graphql_name="cloudFilesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CloudFile_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CloudFileSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch CloudFiles with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CloudFile_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CloudFileSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + column_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("ColumnField"))), + graphql_name="columnFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + ColumnField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches ColumnFields by filtering on id or name + + Arguments: + + * `filter` (`ColumnField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`ColumnFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + column_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(ColumnFieldsConnection), + graphql_name="columnFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + ColumnField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch ColumnFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`ColumnField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + columns = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Column"))), + graphql_name="columns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Columns by filtering on id or name + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + columns_connection = sgqlc.types.Field( + sgqlc.types.non_null(ColumnsConnection), + graphql_name="columnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Columns with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + combined_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("CombinedField")) + ), + graphql_name="combinedFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CombinedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CombinedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches CombinedFields by filtering on id or name + + Arguments: + + * `filter` (`CombinedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CombinedFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + combined_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(CombinedFieldsConnection), + graphql_name="combinedFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CombinedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CombinedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch CombinedFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CombinedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CombinedFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + combined_set_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("CombinedSetField")) + ), + graphql_name="combinedSetFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CombinedSetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CombinedSetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches CombinedSetFields by filtering on id or name + + Arguments: + + * `filter` (`CombinedSetField_Filter`): Filter by GraphQL field + and given value + * `order_by` (`CombinedSetFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + combined_set_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(CombinedSetFieldsConnection), + graphql_name="combinedSetFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CombinedSetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CombinedSetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch CombinedSetFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CombinedSetField_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CombinedSetFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + custom_sqltables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("CustomSQLTable")) + ), + graphql_name="customSQLTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CustomSQLTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CustomSQLTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches CustomSQLTables by filtering on id or name + + Arguments: + + * `filter` (`CustomSQLTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CustomSQLTableSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + custom_sqltables_connection = sgqlc.types.Field( + sgqlc.types.non_null(CustomSQLTablesConnection), + graphql_name="customSQLTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CustomSQLTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CustomSQLTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch CustomSQLTables with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CustomSQLTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CustomSQLTableSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Dashboard"))), + graphql_name="dashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Dashboards by filtering on id or name + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + dashboards_connection = sgqlc.types.Field( + sgqlc.types.non_null(DashboardsConnection), + graphql_name="dashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Dashboards with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_clouds = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("DataCloud"))), + graphql_name="dataClouds", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataCloud_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataCloudSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches DataClouds by filtering on id or name + + Arguments: + + * `filter` (`DataCloud_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DataCloudSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_clouds_connection = sgqlc.types.Field( + sgqlc.types.non_null(DataCloudsConnection), + graphql_name="dataCloudsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataCloud_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataCloudSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch DataClouds with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataCloud_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataCloudSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_quality_certifications = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DataQualityCertification")) + ), + graphql_name="dataQualityCertifications", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityCertification_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityCertificationSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches DataQualityCertifications by filtering on id or name + + Arguments: + + * `filter` (`DataQualityCertification_Filter`): Filter by GraphQL + field and given value + * `order_by` (`DataQualityCertificationSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_quality_certifications_connection = sgqlc.types.Field( + sgqlc.types.non_null(DataQualityCertificationsConnection), + graphql_name="dataQualityCertificationsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityCertification_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityCertificationSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch DataQualityCertifications with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityCertification_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityCertificationSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DataQualityWarning")) + ), + graphql_name="dataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches DataQualityWarnings by filtering on id or name + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + data_quality_warnings_connection = sgqlc.types.Field( + sgqlc.types.non_null(DataQualityWarningsConnection), + graphql_name="dataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch DataQualityWarnings with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + database_servers = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseServer")) + ), + graphql_name="databaseServers", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseServer_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseServerSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches DatabaseServers by filtering on id or name + + Arguments: + + * `filter` (`DatabaseServer_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseServerSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + database_servers_connection = sgqlc.types.Field( + sgqlc.types.non_null(DatabaseServersConnection), + graphql_name="databaseServersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseServer_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseServerSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch DatabaseServers with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseServer_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseServerSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + database_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="databaseTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches DatabaseTables by filtering on id or name + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + database_tables_connection = sgqlc.types.Field( + sgqlc.types.non_null(DatabaseTablesConnection), + graphql_name="databaseTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch DatabaseTables with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="databases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Databases by filtering on id or name + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + databases_connection = sgqlc.types.Field( + sgqlc.types.non_null(DatabasesConnection), + graphql_name="databasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Databases with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + datasource_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatasourceField")) + ), + graphql_name="datasourceFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches DatasourceFields by filtering on id or name + + Arguments: + + * `filter` (`DatasourceField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatasourceFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + datasource_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(DatasourceFieldsConnection), + graphql_name="datasourceFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch DatasourceFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + datasource_filters = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(DatasourceFilter)) + ), + graphql_name="datasourceFilters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches DatasourceFilters by filtering on id or name + + Arguments: + + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + datasource_filters_connection = sgqlc.types.Field( + sgqlc.types.non_null(DatasourceFiltersConnection), + graphql_name="datasourceFiltersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatasourceFilter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceFilterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch DatasourceFilters with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatasourceFilter_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceFilterSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + datasources = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Datasource))), + graphql_name="datasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Datasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Datasources by filtering on id or name + + Arguments: + + * `filter` (`Datasource_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatasourceSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + datasources_connection = sgqlc.types.Field( + sgqlc.types.non_null(DatasourcesConnection), + graphql_name="datasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Datasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Datasources with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Datasource_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + embedded_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("EmbeddedDatasource")) + ), + graphql_name="embeddedDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + EmbeddedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + EmbeddedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches EmbeddedDatasources by filtering on id or name + + Arguments: + + * `filter` (`EmbeddedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`EmbeddedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + embedded_datasources_connection = sgqlc.types.Field( + sgqlc.types.non_null(EmbeddedDatasourcesConnection), + graphql_name="embeddedDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + EmbeddedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + EmbeddedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch EmbeddedDatasources with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`EmbeddedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`EmbeddedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Field))), + graphql_name="fields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Fields by filtering on id or name + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(FieldsConnection), + graphql_name="fieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Fields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + files = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("File"))), + graphql_name="files", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(File_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FileSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Files by filtering on id or name + + Arguments: + + * `filter` (`File_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FileSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + files_connection = sgqlc.types.Field( + sgqlc.types.non_null(FilesConnection), + graphql_name="filesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(File_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FileSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Files with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`File_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FileSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow_column_input_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("FlowColumnInputField")) + ), + graphql_name="flowColumnInputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowColumnInputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowColumnInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches FlowColumnInputFields by filtering on id or name + + Arguments: + + * `filter` (`FlowColumnInputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowColumnInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow_column_input_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(FlowColumnInputFieldsConnection), + graphql_name="flowColumnInputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowColumnInputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowColumnInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch FlowColumnInputFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowColumnInputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowColumnInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow_column_output_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("FlowColumnOutputField")) + ), + graphql_name="flowColumnOutputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowColumnOutputField_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowColumnOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches FlowColumnOutputFields by filtering on id or name + + Arguments: + + * `filter` (`FlowColumnOutputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowColumnOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow_column_output_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(FlowColumnOutputFieldsConnection), + graphql_name="flowColumnOutputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowColumnOutputField_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowColumnOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch FlowColumnOutputFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowColumnOutputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowColumnOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow_field_input_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("FlowFieldInputField")) + ), + graphql_name="flowFieldInputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldInputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """Fetches FlowFieldInputFields by filtering on id or name + + Arguments: + + * `filter` (`FlowFieldInputField_Filter`): Filter by GraphQL field + and given value + * `order_by` (`FlowFieldInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + flow_field_input_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(FlowFieldInputFieldsConnection), + graphql_name="flowFieldInputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldInputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """Fetch FlowFieldInputFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldInputField_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + flow_field_output_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("FlowFieldOutputField")) + ), + graphql_name="flowFieldOutputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches FlowFieldOutputFields by filtering on id or name + + Arguments: + + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow_field_output_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(FlowFieldOutputFieldsConnection), + graphql_name="flowFieldOutputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch FlowFieldOutputFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow_output_steps = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FlowOutputStep))), + graphql_name="flowOutputSteps", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowOutputStep_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputStepSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches FlowOutputSteps by filtering on id or name + + Arguments: + + * `filter` (`FlowOutputStep_Filter`): Filter by GraphQL field and + given value + * `order_by` (`FlowOutputStepSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flow_output_steps_connection = sgqlc.types.Field( + sgqlc.types.non_null(FlowOutputStepsConnection), + graphql_name="flowOutputStepsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowOutputStep_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputStepSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch FlowOutputSteps with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowOutputStep_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowOutputStepSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="flows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Flows by filtering on id or name + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flows_connection = sgqlc.types.Field( + sgqlc.types.non_null(FlowsConnection), + graphql_name="flowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Flows with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + generic_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("GenericLabel"))), + graphql_name="genericLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + GenericLabel_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + GenericLabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches GenericLabels by filtering on id or name + + Arguments: + + * `filter` (`GenericLabel_Filter`): Filter by GraphQL field and + given value + * `order_by` (`GenericLabelSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + generic_labels_connection = sgqlc.types.Field( + sgqlc.types.non_null(GenericLabelsConnection), + graphql_name="genericLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + GenericLabel_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + GenericLabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch GenericLabels with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`GenericLabel_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`GenericLabelSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + group_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("GroupField"))), + graphql_name="groupFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + GroupField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + GroupFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches GroupFields by filtering on id or name + + Arguments: + + * `filter` (`GroupField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`GroupFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + group_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(GroupFieldsConnection), + graphql_name="groupFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + GroupField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + GroupFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch GroupFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`GroupField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`GroupFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + hierarchy_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("HierarchyField")) + ), + graphql_name="hierarchyFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + HierarchyField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + HierarchyFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches HierarchyFields by filtering on id or name + + Arguments: + + * `filter` (`HierarchyField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`HierarchyFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + hierarchy_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(HierarchyFieldsConnection), + graphql_name="hierarchyFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + HierarchyField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + HierarchyFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch HierarchyFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`HierarchyField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`HierarchyFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + lens_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LensField))), + graphql_name="lensFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches LensFields by filtering on id or name + + Arguments: + + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + lens_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null(LensFieldsConnection), + graphql_name="lensFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + LensField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch LensFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`LensField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + lenses = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Lens))), + graphql_name="lenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Lenses by filtering on id or name + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + lenses_connection = sgqlc.types.Field( + sgqlc.types.non_null(LensesConnection), + graphql_name="lensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Lenss with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metric_definitions = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(MetricDefinition)) + ), + graphql_name="metricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches MetricDefinitions by filtering on id or name + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metric_definitions_connection = sgqlc.types.Field( + sgqlc.types.non_null(MetricDefinitionsConnection), + graphql_name="metricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch MetricDefinitions with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metrics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Metric"))), + graphql_name="metrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Metrics by filtering on id or name + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metrics_connection = sgqlc.types.Field( + sgqlc.types.non_null(MetricsConnection), + graphql_name="metricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Metrics with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parameters = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Parameter))), + graphql_name="parameters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Parameters by filtering on id or name + + Arguments: + + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parameters_connection = sgqlc.types.Field( + sgqlc.types.non_null(ParametersConnection), + graphql_name="parametersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Parameters with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + published_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="publishedDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches PublishedDatasources by filtering on id or name + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + published_datasources_connection = sgqlc.types.Field( + sgqlc.types.non_null(PublishedDatasourcesConnection), + graphql_name="publishedDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch PublishedDatasources with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + set_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("SetField"))), + graphql_name="setFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches SetFields by filtering on id or name + + Arguments: + + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + set_fields_connection = sgqlc.types.Field( + sgqlc.types.non_null("SetFieldsConnection"), + graphql_name="setFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + SetField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SetFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch SetFields with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`SetField_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SetFieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Sheet"))), + graphql_name="sheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Sheets by filtering on id or name + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets_connection = sgqlc.types.Field( + sgqlc.types.non_null("SheetsConnection"), + graphql_name="sheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Sheets with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + table_additional_detailses = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("TableAdditionalDetails")) + ), + graphql_name="tableAdditionalDetailses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableAdditionalDetails_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableAdditionalDetailsSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """Fetches TableAdditionalDetailses by filtering on id or name + + Arguments: + + * `filter` (`TableAdditionalDetails_Filter`): Filter by GraphQL + field and given value + * `order_by` (`TableAdditionalDetailsSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + table_additional_detailses_connection = sgqlc.types.Field( + sgqlc.types.non_null("TableAdditionalDetailsesConnection"), + graphql_name="tableAdditionalDetailsesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableAdditionalDetails_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableAdditionalDetailsSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ) + ), + ) + """Fetch TableAdditionalDetailss with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableAdditionalDetails_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableAdditionalDetailsSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + """ + + tableau_sites = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TableauSite"))), + graphql_name="tableauSites", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauSite_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauSiteSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Fetches TableauSites by filtering on id or name + + Arguments: + + * `filter` (`TableauSite_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauSiteSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + tableau_sites_connection = sgqlc.types.Field( + sgqlc.types.non_null("TableauSitesConnection"), + graphql_name="tableauSitesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauSite_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauSiteSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Fetch TableauSites with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauSite_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauSiteSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + tableau_users = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TableauUser"))), + graphql_name="tableauUsers", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Fetches TableauUsers by filtering on id or name + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + tableau_users_connection = sgqlc.types.Field( + sgqlc.types.non_null("TableauUsersConnection"), + graphql_name="tableauUsersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Fetch TableauUsers with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Table))), + graphql_name="tables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Table_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + TableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Tables by filtering on id or name + + Arguments: + + * `filter` (`Table_Filter`): Filter by GraphQL field and given + value + * `order_by` (`TableSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + tables_connection = sgqlc.types.Field( + sgqlc.types.non_null("TablesConnection"), + graphql_name="tablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Table_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Tables with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Table_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + tags = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Tag"))), + graphql_name="tags", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Tag_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg(TagSortOrder, graphql_name="orderBy", default=None), + ), + ) + ), + ) + """Fetches Tags by filtering on id or name + + Arguments: + + * `filter` (`Tag_Filter`): Filter by GraphQL field and given value + * `order_by` (`TagSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + """ + + tags_connection = sgqlc.types.Field( + sgqlc.types.non_null("TagsConnection"), + graphql_name="tagsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Tag_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg(TagSortOrder, graphql_name="orderBy", default=None), + ), + ) + ), + ) + """Fetch Tags with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Tag_Filter`): Filter by GraphQL field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TagSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + """ + + views = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(View))), + graphql_name="views", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(View_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ViewSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Views by filtering on id or name + + Arguments: + + * `filter` (`View_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ViewSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + views_connection = sgqlc.types.Field( + sgqlc.types.non_null("ViewsConnection"), + graphql_name="viewsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(View_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ViewSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Views with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`View_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ViewSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="virtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches VirtualConnectionTables by filtering on id or name + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + virtual_connection_tables_connection = sgqlc.types.Field( + sgqlc.types.non_null("VirtualConnectionTablesConnection"), + graphql_name="virtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch VirtualConnectionTables with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="virtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches VirtualConnections by filtering on id or name + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + virtual_connections_connection = sgqlc.types.Field( + sgqlc.types.non_null("VirtualConnectionsConnection"), + graphql_name="virtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch VirtualConnections with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + web_data_connectors = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("WebDataConnector")) + ), + graphql_name="webDataConnectors", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + WebDataConnector_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WebDataConnectorSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches WebDataConnectors by filtering on id or name + + Arguments: + + * `filter` (`WebDataConnector_Filter`): Filter by GraphQL field + and given value + * `order_by` (`WebDataConnectorSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + web_data_connectors_connection = sgqlc.types.Field( + sgqlc.types.non_null("WebDataConnectorsConnection"), + graphql_name="webDataConnectorsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + WebDataConnector_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WebDataConnectorSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch WebDataConnectors with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`WebDataConnector_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WebDataConnectorSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + workbooks = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Workbook"))), + graphql_name="workbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetches Workbooks by filtering on id or name + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + workbooks_connection = sgqlc.types.Field( + sgqlc.types.non_null("WorkbooksConnection"), + graphql_name="workbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fetch Workbooks with support for pagination + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class SetFieldsConnection(sgqlc.types.relay.Connection): + """Connection Type for SetField""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("SetField"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class SheetsConnection(sgqlc.types.relay.Connection): + """Connection Type for Sheet""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Sheet"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class TableAdditionalDetails(sgqlc.types.Type): + """Additional details for the DatabaseTable type *Available in + Tableau Cloud February 2024 / Server 2024.2 and later.* + """ + + __schema__ = tableau_schema + __field_names__ = ( + "category", + "cdp_internal_id", + "created_by", + "data_cloud_api_name", + "id", + "table", + "table_connection", + ) + category = sgqlc.types.Field(String, graphql_name="category") + """Category of the Data Cloud object""" + + cdp_internal_id = sgqlc.types.Field(String, graphql_name="cdpInternalId") + """Internal ID of the Data Cloud object""" + + created_by = sgqlc.types.Field(String, graphql_name="createdBy") + """The Data Cloud user who created this object""" + + data_cloud_api_name = sgqlc.types.Field(String, graphql_name="dataCloudApiName") + """API name of the Data Cloud object""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used with the Metadata API. Not the same as the + locally unique identifier used with the REST API. + """ + + table = sgqlc.types.Field( + sgqlc.types.list_of("DatabaseTable"), + graphql_name="table", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that this additional detail is for + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + table_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="tableConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that this additional detail is for + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class TableAdditionalDetailsesConnection(sgqlc.types.relay.Connection): + """Connection Type for TableAdditionalDetails""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(TableAdditionalDetails)) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class TableauSite(sgqlc.types.Type): + """Site on Tableau server""" + + __schema__ = tableau_schema + __field_names__ = ( + "created_at", + "flows", + "flows_connection", + "id", + "lenses", + "lenses_connection", + "luid", + "metric_definitions", + "metric_definitions_connection", + "metrics", + "metrics_connection", + "name", + "published_datasources", + "published_datasources_connection", + "uri", + "virtual_connections", + "virtual_connections_connection", + "workbooks", + "workbooks_connection", + ) + created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt") + """Time the site was created. Available in Tableau Cloud June 2022 / + Server 2022.3 and later. + """ + + flows = sgqlc.types.Field( + sgqlc.types.list_of("Flow"), + graphql_name="flows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are part of this site + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="flowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are part of this site + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + lenses = sgqlc.types.Field( + sgqlc.types.list_of(Lens), + graphql_name="lenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Lenses that are part of this site + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + lenses_connection = sgqlc.types.Field( + LensesConnection, + graphql_name="lensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Lenses that are part of this site + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + metric_definitions = sgqlc.types.Field( + sgqlc.types.list_of(MetricDefinition), + graphql_name="metricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions that are part of this site. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metric_definitions_connection = sgqlc.types.Field( + MetricDefinitionsConnection, + graphql_name="metricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions that are part of this site. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metrics = sgqlc.types.Field( + sgqlc.types.list_of("Metric"), + graphql_name="metrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Metrics that are part of this site + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metrics_connection = sgqlc.types.Field( + MetricsConnection, + graphql_name="metricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Metrics that are part of this site + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """Name shown in server""" + + published_datasources = sgqlc.types.Field( + sgqlc.types.list_of("PublishedDatasource"), + graphql_name="publishedDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The published data sources that are part of this site + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + published_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="publishedDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The published data sources that are part of this site + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + uri = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="uri") + """URI of this site, e.g., 'sites/4' """ + + virtual_connections = sgqlc.types.Field( + sgqlc.types.list_of("VirtualConnection"), + graphql_name="virtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connections that are part of this site + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="virtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connections that are part of this site + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + workbooks = sgqlc.types.Field( + sgqlc.types.list_of("Workbook"), + graphql_name="workbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The workbooks that are part of this site + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + workbooks_connection = sgqlc.types.Field( + "WorkbooksConnection", + graphql_name="workbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The workbooks that are part of this site + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class TableauSitesConnection(sgqlc.types.relay.Connection): + """Connection Type for TableauSite""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(TableauSite))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class TableauUser(sgqlc.types.Type): + """User on a site on Tableau server""" + + __schema__ = tableau_schema + __field_names__ = ( + "authored_data_quality_certifications", + "authored_data_quality_certifications_connection", + "authored_data_quality_warnings", + "authored_data_quality_warnings_connection", + "authored_labels", + "authored_labels_connection", + "certified_databases", + "certified_databases_connection", + "certified_datasources", + "certified_datasources_connection", + "certified_tables", + "certified_tables_connection", + "contact_for_databases", + "contact_for_databases_connection", + "contact_for_tables", + "contact_for_tables_connection", + "domain", + "email", + "id", + "luid", + "name", + "owned_datasources", + "owned_datasources_connection", + "owned_flows", + "owned_flows_connection", + "owned_lenses", + "owned_lenses_connection", + "owned_metrics", + "owned_metrics_connection", + "owned_virtual_connection_tables", + "owned_virtual_connection_tables_connection", + "owned_virtual_connections", + "owned_virtual_connections_connection", + "owned_workbooks", + "owned_workbooks_connection", + "uri", + "username", + "vizportal_id", + ) + authored_data_quality_certifications = sgqlc.types.Field( + sgqlc.types.list_of("DataQualityCertification"), + graphql_name="authoredDataQualityCertifications", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityCertification_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityCertificationSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality certifications this user has authored + + Arguments: + + * `filter` (`DataQualityCertification_Filter`): Filter by GraphQL + field and given value + * `order_by` (`DataQualityCertificationSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + authored_data_quality_certifications_connection = sgqlc.types.Field( + DataQualityCertificationsConnection, + graphql_name="authoredDataQualityCertificationsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityCertification_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityCertificationSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality certifications this user has authored + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityCertification_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityCertificationSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + authored_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.list_of("DataQualityWarning"), + graphql_name="authoredDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality warnings this user has authored + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + authored_data_quality_warnings_connection = sgqlc.types.Field( + DataQualityWarningsConnection, + graphql_name="authoredDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data quality warnings this user has authored + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + authored_labels = sgqlc.types.Field( + sgqlc.types.list_of(Label), + graphql_name="authoredLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The labels this user has authored + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + authored_labels_connection = sgqlc.types.Field( + LabelsConnection, + graphql_name="authoredLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The labels this user has authored + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + certified_databases = sgqlc.types.Field( + sgqlc.types.list_of(Database), + graphql_name="certifiedDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The databases that this user has certified + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + certified_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="certifiedDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The databases that this user has certified + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + certified_datasources = sgqlc.types.Field( + sgqlc.types.list_of("PublishedDatasource"), + graphql_name="certifiedDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The published data sources that this user has certified + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + certified_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="certifiedDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The published data sources that this user has certified + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + certified_tables = sgqlc.types.Field( + sgqlc.types.list_of("DatabaseTable"), + graphql_name="certifiedTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that this user has certified + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + certified_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="certifiedTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that this user has certified + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + contact_for_databases = sgqlc.types.Field( + sgqlc.types.list_of(Database), + graphql_name="contactForDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The databases that this user is the contact for + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + contact_for_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="contactForDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The databases that this user is the contact for + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + contact_for_tables = sgqlc.types.Field( + sgqlc.types.list_of("DatabaseTable"), + graphql_name="contactForTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that this user is the contact for + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + contact_for_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="contactForTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that this user is the contact for + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + domain = sgqlc.types.Field(String, graphql_name="domain") + """Domain this user belongs to""" + + email = sgqlc.types.Field(String, graphql_name="email") + """Email address of this user""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API. Not the same as the + numeric ID used on server + """ + + luid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="luid") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """Display name of this user""" + + owned_datasources = sgqlc.types.Field( + sgqlc.types.list_of("PublishedDatasource"), + graphql_name="ownedDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The published data sources that belong to this user + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="ownedDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The published data sources that belong to this user + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_flows = sgqlc.types.Field( + sgqlc.types.list_of("Flow"), + graphql_name="ownedFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that belong to this user + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="ownedFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that belong to this user + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_lenses = sgqlc.types.Field( + sgqlc.types.list_of(Lens), + graphql_name="ownedLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Lenses that belong to this user + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_lenses_connection = sgqlc.types.Field( + LensesConnection, + graphql_name="ownedLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Lenses that belong to this user + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_metrics = sgqlc.types.Field( + sgqlc.types.list_of("Metric"), + graphql_name="ownedMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Metrics that belong to this user + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_metrics_connection = sgqlc.types.Field( + MetricsConnection, + graphql_name="ownedMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Metrics that belong to this user + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.list_of("VirtualConnectionTable"), + graphql_name="ownedVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection tables that belong to this user + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="ownedVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection tables that belong to this user + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_virtual_connections = sgqlc.types.Field( + sgqlc.types.list_of("VirtualConnection"), + graphql_name="ownedVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connections that belong to this user + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="ownedVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connections that belong to this user + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_workbooks = sgqlc.types.Field( + sgqlc.types.list_of("Workbook"), + graphql_name="ownedWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The workbooks that belong to this user + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owned_workbooks_connection = sgqlc.types.Field( + "WorkbooksConnection", + graphql_name="ownedWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The workbooks that belong to this user + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + uri = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="uri") + """URI of this user, e.g., 'sites/1/users/1396' """ + + username = sgqlc.types.Field(String, graphql_name="username") + """Username of this user""" + + vizportal_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalId" + ) + """Vizportal ID of this user, for use in client-to-server + communications + """ + + +class TableauUsersConnection(sgqlc.types.relay.Connection): + """Connection Type for TableauUser""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(TableauUser))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class TablesConnection(sgqlc.types.relay.Connection): + """Connection Type for Table""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Table))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class Tag(sgqlc.types.Type): + """A tag associated with content items""" + + __schema__ = tableau_schema + __field_names__ = ( + "assets", + "assets_connection", + "columns", + "columns_connection", + "database_tables", + "database_tables_connection", + "databases", + "databases_connection", + "flows", + "flows_connection", + "id", + "metrics", + "metrics_connection", + "name", + "published_datasources", + "published_datasources_connection", + "views", + "views_connection", + "virtual_connection_tables", + "virtual_connection_tables_connection", + "virtual_connections", + "virtual_connections_connection", + "workbooks", + "workbooks_connection", + ) + assets = sgqlc.types.Field( + sgqlc.types.list_of(Taggable), + graphql_name="assets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Taggable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TaggableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The assets that are associated with this tag + + Arguments: + + * `filter` (`Taggable_Filter`): Filter by GraphQL field and given + value + * `order_by` (`TaggableSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + assets_connection = sgqlc.types.Field( + "TaggablesConnection", + graphql_name="assetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Taggable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TaggableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The assets that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Taggable_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TaggableSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + columns = sgqlc.types.Field( + sgqlc.types.list_of("Column"), + graphql_name="columns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The columns that are associated with this tag + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + columns_connection = sgqlc.types.Field( + ColumnsConnection, + graphql_name="columnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The columns that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + database_tables = sgqlc.types.Field( + sgqlc.types.list_of("DatabaseTable"), + graphql_name="databaseTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that are associated with this tag + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + database_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="databaseTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + databases = sgqlc.types.Field( + sgqlc.types.list_of(Database), + graphql_name="databases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The databases that are associated with this tag + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="databasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The databases that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flows = sgqlc.types.Field( + sgqlc.types.list_of("Flow"), + graphql_name="flows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are associated with this tag + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="flowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """Unique identifier used by the metadata API.""" + + metrics = sgqlc.types.Field( + sgqlc.types.list_of("Metric"), + graphql_name="metrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Metrics that are associated with this tag + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + metrics_connection = sgqlc.types.Field( + MetricsConnection, + graphql_name="metricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Metrics that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of the tag""" + + published_datasources = sgqlc.types.Field( + sgqlc.types.list_of("PublishedDatasource"), + graphql_name="publishedDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The published datasources that are associated with this tag + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + published_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="publishedDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The published datasources that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + views = sgqlc.types.Field( + sgqlc.types.list_of(View), + graphql_name="views", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(View_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ViewSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The views that are associated with this tag + + Arguments: + + * `filter` (`View_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ViewSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + views_connection = sgqlc.types.Field( + "ViewsConnection", + graphql_name="viewsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(View_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ViewSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The views that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`View_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ViewSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.list_of("VirtualConnectionTable"), + graphql_name="virtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection tables that are associated with this tag + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + virtual_connection_tables_connection = sgqlc.types.Field( + "VirtualConnectionTablesConnection", + graphql_name="virtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection tables that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + virtual_connections = sgqlc.types.Field( + sgqlc.types.list_of("VirtualConnection"), + graphql_name="virtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connections that are associated with this tag + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + virtual_connections_connection = sgqlc.types.Field( + "VirtualConnectionsConnection", + graphql_name="virtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connections that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + workbooks = sgqlc.types.Field( + sgqlc.types.list_of("Workbook"), + graphql_name="workbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The workbooks that are associated with this tag + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + workbooks_connection = sgqlc.types.Field( + "WorkbooksConnection", + graphql_name="workbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The workbooks that are associated with this tag + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class TaggablesConnection(sgqlc.types.relay.Connection): + """Connection Type for Taggable""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Taggable))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class TagsConnection(sgqlc.types.relay.Connection): + """Connection Type for Tag""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Tag))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class ViewsConnection(sgqlc.types.relay.Connection): + """Connection Type for View""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(View))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class VirtualConnectionTablesConnection(sgqlc.types.relay.Connection): + """Connection Type for VirtualConnectionTable""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class VirtualConnectionsConnection(sgqlc.types.relay.Connection): + """Connection Type for VirtualConnection""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class WarnablesConnection(sgqlc.types.relay.Connection): + """Connection Type for Warnable""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Warnable))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class WebDataConnectorsConnection(sgqlc.types.relay.Connection): + """Connection Type for WebDataConnector""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("WebDataConnector")) + ), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class WorkbooksConnection(sgqlc.types.relay.Connection): + """Connection Type for Workbook""" + + __schema__ = tableau_schema + __field_names__ = ("nodes", "page_info", "total_count") + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Workbook"))), + graphql_name="nodes", + ) + """List of nodes""" + + page_info = sgqlc.types.Field( + sgqlc.types.non_null(PageInfo), graphql_name="pageInfo" + ) + """Information for pagination""" + + total_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalCount" + ) + """Total number of objects in connection""" + + +class BinField(sgqlc.types.Type, DataField, Field, FieldReferencingField, Node): + """GraphQL type for a binned continuous measure field. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/calculations_bins.html + """ + + __schema__ = tableau_schema + __field_names__ = ("bin_size", "formula", "parameters", "parameters_connection") + bin_size = sgqlc.types.Field(String, graphql_name="binSize") + """Size of the bin""" + + formula = sgqlc.types.Field(String, graphql_name="formula") + """Formula of the calculated field""" + + parameters = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Parameter))), + graphql_name="parameters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of parameters, if any, used in this field + + Arguments: + + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parameters_connection = sgqlc.types.Field( + ParametersConnection, + graphql_name="parametersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of parameters, if any, used in this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class CalculatedField( + sgqlc.types.Type, AnalyticsField, DataField, Field, FieldReferencingField, Node +): + """GraphQL type for a calculated field. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/calculations_calculatedfields.html + """ + + __schema__ = tableau_schema + __field_names__ = ( + "formula", + "has_user_reference", + "is_auto_generated", + "parameters", + "parameters_connection", + "sheet", + ) + formula = sgqlc.types.Field(String, graphql_name="formula") + """Formula of the calculated field""" + + has_user_reference = sgqlc.types.Field(Boolean, graphql_name="hasUserReference") + """True if field formula that involves a user function (for example, + USERNAME or ISMEMBEROF) + """ + + is_auto_generated = sgqlc.types.Field(Boolean, graphql_name="isAutoGenerated") + """True if Tableau automatically created this field. A list of + autogenerated fields are here: + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/datafields_understanddatawindow.html#AutoFields + """ + + parameters = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Parameter))), + graphql_name="parameters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of parameters, if any, used in this field + + Arguments: + + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parameters_connection = sgqlc.types.Field( + ParametersConnection, + graphql_name="parametersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of parameters, if any, used in this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheet = sgqlc.types.Field("Sheet", graphql_name="sheet") + """Sheet that contains this calculated field""" + + +class CloudFile( + sgqlc.types.Type, CanHaveLabels, Certifiable, Database, Taggable, Warnable +): + """A cloud file connection""" + + __schema__ = tableau_schema + __field_names__ = ( + "file_extension", + "file_id", + "mime_type", + "provider", + "request_url", + ) + file_extension = sgqlc.types.Field(String, graphql_name="fileExtension") + """The file extension""" + + file_id = sgqlc.types.Field(String, graphql_name="fileId") + """The ID used by the provider for the cloud file. Each provider uses + IDs in a different format. + """ + + mime_type = sgqlc.types.Field(String, graphql_name="mimeType") + """The MIME type""" + + provider = sgqlc.types.Field(String, graphql_name="provider") + """The provider of the cloud file, e.g., onedrive, google-sheets, + dropbox, and box + """ + + request_url = sgqlc.types.Field(String, graphql_name="requestUrl") + """URL for requesting the cloud file""" + + +class Column(sgqlc.types.Type, CanHaveLabels, Node, Taggable, Warnable): + """GraphQL type for a table column""" + + __schema__ = tableau_schema + __field_names__ = ( + "description", + "description_inherited", + "display_name", + "downstream_columns", + "downstream_columns_connection", + "downstream_dashboards", + "downstream_dashboards_connection", + "downstream_databases", + "downstream_databases_connection", + "downstream_datasources", + "downstream_datasources_connection", + "downstream_fields", + "downstream_fields_connection", + "downstream_flows", + "downstream_flows_connection", + "downstream_lenses", + "downstream_lenses_connection", + "downstream_metric_definitions", + "downstream_metric_definitions_connection", + "downstream_metrics", + "downstream_metrics_connection", + "downstream_owners", + "downstream_owners_connection", + "downstream_sheets", + "downstream_sheets_connection", + "downstream_tables", + "downstream_tables_connection", + "downstream_virtual_connection_tables", + "downstream_virtual_connection_tables_connection", + "downstream_virtual_connections", + "downstream_virtual_connections_connection", + "downstream_workbooks", + "downstream_workbooks_connection", + "is_nullable", + "referenced_by_fields", + "referenced_by_fields_connection", + "referenced_by_flow_column_input_field", + "referenced_by_flow_column_input_field_connection", + "referenced_by_flow_column_output_field", + "referenced_by_flow_column_output_field_connection", + "referenced_by_remote_column", + "referenced_by_remote_column_connection", + "remote_column", + "remote_type", + "table", + "upstream_columns", + "upstream_columns_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_fields", + "upstream_fields_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "upstream_virtual_connections", + "upstream_virtual_connections_connection", + "vizportal_id", + ) + description = sgqlc.types.Field(String, graphql_name="description") + """User modifiable description of this column""" + + description_inherited = sgqlc.types.Field( + sgqlc.types.list_of(InheritedStringResult), + graphql_name="descriptionInherited", + args=sgqlc.types.ArgDict( + ( + ( + "inheritance_type", + sgqlc.types.Arg( + InheritanceType, graphql_name="inheritanceType", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, graphql_name="permissionMode", default=None + ), + ), + ) + ), + ) + """description that is shown in the Tableau UI + + Arguments: + + * `inheritance_type` (`InheritanceType`): Method for selecting + inherited value + * `permission_mode` (`PermissionMode`): Option to select how to + apply permissions. By default it is OBFUSCATE_RESULTS + """ + + display_name = sgqlc.types.Field(String, graphql_name="displayName") + """Optional display name for column""" + + downstream_columns = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Column"))), + graphql_name="downstreamColumns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Columns downstream from the column + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_columns_connection = sgqlc.types.Field( + ColumnsConnection, + graphql_name="downstreamColumnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Columns downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Dashboard"))), + graphql_name="downstreamDashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards downstream from the column + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards_connection = sgqlc.types.Field( + DashboardsConnection, + graphql_name="downstreamDashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="downstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases downstream from the column + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="downstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="downstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Published datasources downstream from the column + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="downstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Published datasources downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Field))), + graphql_name="downstreamFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields downstream from the column + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_fields_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="downstreamFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="downstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream from the column + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="downstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Lens))), + graphql_name="downstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses downstream from the column + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses_connection = sgqlc.types.Field( + LensesConnection, + graphql_name="downstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions = sgqlc.types.Field( + sgqlc.types.list_of(MetricDefinition), + graphql_name="downstreamMetricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from the column. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions_connection = sgqlc.types.Field( + MetricDefinitionsConnection, + graphql_name="downstreamMetricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from the column. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Metric"))), + graphql_name="downstreamMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics downstream from the column + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics_connection = sgqlc.types.Field( + MetricsConnection, + graphql_name="downstreamMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_owners = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(TableauUser))), + graphql_name="downstreamOwners", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners of workbooks and published datasources downstream from the + column + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_owners_connection = sgqlc.types.Field( + TableauUsersConnection, + graphql_name="downstreamOwnersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners of workbooks and published datasources downstream from the + column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Sheet"))), + graphql_name="downstreamSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets downstream from the column + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_sheets_connection = sgqlc.types.Field( + SheetsConnection, + graphql_name="downstreamSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="downstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables downstream from the column + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="downstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="downstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream from the column + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables_connection = sgqlc.types.Field( + VirtualConnectionTablesConnection, + graphql_name="downstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="downstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections downstream from the column + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections_connection = sgqlc.types.Field( + VirtualConnectionsConnection, + graphql_name="downstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Workbook"))), + graphql_name="downstreamWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks downstream from the column + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks_connection = sgqlc.types.Field( + WorkbooksConnection, + graphql_name="downstreamWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks downstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + is_nullable = sgqlc.types.Field(Boolean, graphql_name="isNullable") + """True if this column may contain null values""" + + referenced_by_fields = sgqlc.types.Field( + sgqlc.types.list_of("ColumnField"), + graphql_name="referencedByFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + ColumnField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The column field that references this column + + Arguments: + + * `filter` (`ColumnField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`ColumnFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_fields_connection = sgqlc.types.Field( + ColumnFieldsConnection, + graphql_name="referencedByFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + ColumnField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The column field that references this column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`ColumnField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnFieldSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_column_input_field = sgqlc.types.Field( + sgqlc.types.list_of("FlowColumnInputField"), + graphql_name="referencedByFlowColumnInputField", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowColumnInputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowColumnInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow input field that wraps this column + + Arguments: + + * `filter` (`FlowColumnInputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowColumnInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_column_input_field_connection = sgqlc.types.Field( + FlowColumnInputFieldsConnection, + graphql_name="referencedByFlowColumnInputFieldConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowColumnInputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowColumnInputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow input field that wraps this column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowColumnInputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowColumnInputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_column_output_field = sgqlc.types.Field( + sgqlc.types.list_of("FlowColumnOutputField"), + graphql_name="referencedByFlowColumnOutputField", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowColumnOutputField_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowColumnOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow output field that wraps this column + + Arguments: + + * `filter` (`FlowColumnOutputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowColumnOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_flow_column_output_field_connection = sgqlc.types.Field( + FlowColumnOutputFieldsConnection, + graphql_name="referencedByFlowColumnOutputFieldConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowColumnOutputField_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowColumnOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A flow output field that wraps this column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowColumnOutputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowColumnOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_remote_column = sgqlc.types.Field( + sgqlc.types.list_of("Column"), + graphql_name="referencedByRemoteColumn", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A column that logically represents this column. + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_remote_column_connection = sgqlc.types.Field( + ColumnsConnection, + graphql_name="referencedByRemoteColumnConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """A column that logically represents this column. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + remote_column = sgqlc.types.Field("Column", graphql_name="remoteColumn") + """A column that this column logically represents.""" + + remote_type = sgqlc.types.Field( + sgqlc.types.non_null(RemoteType), graphql_name="remoteType" + ) + """Remote type on the database. Types correspond to OLEDB types here: + https://referencesource.microsoft.com/#system.data/System/Data/Ole + Db/OLEDB_Enum.cs,364 + """ + + table = sgqlc.types.Field(Table, graphql_name="table") + """The table that this column belongs to""" + + upstream_columns = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of("Column")), + graphql_name="upstreamColumns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """All upstream columns this column references + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_columns_connection = sgqlc.types.Field( + ColumnsConnection, + graphql_name="upstreamColumnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """All upstream columns this column references + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream from the Table + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream from the Table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream from this column + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream from this column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(Field)), + graphql_name="upstreamFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """fields that are upstream of this column + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="upstreamFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """fields that are upstream of this column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows connected upstream from the column + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows connected upstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream from the column + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream from the column + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + VirtualConnectionTablesConnection, + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables upstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="upstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections upstream from the column + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections_connection = sgqlc.types.Field( + VirtualConnectionsConnection, + graphql_name="upstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections upstream from the column + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + vizportal_id = sgqlc.types.Field(String, graphql_name="vizportalId") + """Vizportal ID of this column, for use in client-to-server + communications + """ + + +class ColumnField(sgqlc.types.Type, AnalyticsField, DataField, Field, Node): + """ColumnFields are a type of field which directly connects to a + column in some type of table. + """ + + __schema__ = tableau_schema + __field_names__ = ("columns", "columns_connection") + columns = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Column))), + graphql_name="columns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of columns, if any, that this field references + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + columns_connection = sgqlc.types.Field( + ColumnsConnection, + graphql_name="columnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of columns, if any, that this field references + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class CombinedField(sgqlc.types.Type, Field, FieldReferencingField, Node): + """GraphQL type for a combined field. Combined fields concatanate + fields together into one string. + """ + + __schema__ = tableau_schema + __field_names__ = () + + +class CombinedSetField(sgqlc.types.Type, Field, FieldReferencingField, Node): + """GraphQL type for a combined set field. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/sortgroup_sets_create.html#Combine + """ + + __schema__ = tableau_schema + __field_names__ = ("combination_type", "delimiter") + combination_type = sgqlc.types.Field(String, graphql_name="combinationType") + """How the sets are combined. 'All Members in Both Sets', 'Shared + Members in Both Sets', or 'Except Shared Members' + """ + + delimiter = sgqlc.types.Field(String, graphql_name="delimiter") + """Delimiter used to separate members of the two sets. Usually ',' or + ';' + """ + + +class CustomSQLTable(sgqlc.types.Type, Table): + """A table that represents the result of evaluating a custom SQL + query. These "tables" are owned by the Tableau data source + (embedded or published) which contains the SQL query, so they only + exist within that data source. + """ + + __schema__ = tableau_schema + __field_names__ = ( + "connection_type", + "database", + "is_unsupported_custom_sql", + "query", + "tables", + "tables_connection", + ) + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type shortname""" + + database = sgqlc.types.Field(Database, graphql_name="database") + """Database this query is executed on""" + + is_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="isUnsupportedCustomSql" + ) + """True if the query is unsupported by Tableau Catalog, in which case + lineage may be incomplete + """ + + query = sgqlc.types.Field(String, graphql_name="query") + """Text of the query""" + + tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("DatabaseTable")) + ), + graphql_name="tables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Actual tables that this query references. + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="tablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Actual tables that this query references. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class Dashboard(sgqlc.types.Type, Taggable, View): + """A dashboard contained in a published workbook.""" + + __schema__ = tableau_schema + __field_names__ = ( + "ask_data_extensions", + "ask_data_extensions_connection", + "sheets", + "sheets_connection", + "upstream_columns", + "upstream_columns_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_fields", + "upstream_fields_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_lenses", + "upstream_lenses_connection", + "upstream_sheet_field_instances", + "upstream_sheet_field_instances_connection", + "upstream_tables", + "upstream_tables_connection", + ) + ask_data_extensions = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(AskDataExtension)) + ), + graphql_name="askDataExtensions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + AskDataExtension_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + AskDataExtensionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """AskDataExtensions that are added into this dashboard + + Arguments: + + * `filter` (`AskDataExtension_Filter`): Filter by GraphQL field + and given value + * `order_by` (`AskDataExtensionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + ask_data_extensions_connection = sgqlc.types.Field( + AskDataExtensionsConnection, + graphql_name="askDataExtensionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + AskDataExtension_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + AskDataExtensionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """AskDataExtensions that are added into this dashboard + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`AskDataExtension_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`AskDataExtensionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Sheet"))), + graphql_name="sheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets referenced by this dashboard + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets_connection = sgqlc.types.Field( + SheetsConnection, + graphql_name="sheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets referenced by this dashboard + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_columns = sgqlc.types.Field( + sgqlc.types.list_of(Column), + graphql_name="upstreamColumns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The columns that are upstream of this dashboard + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_columns_connection = sgqlc.types.Field( + ColumnsConnection, + graphql_name="upstreamColumnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The columns that are upstream of this dashboard + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.list_of(Database), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The databases that are upstream of this dashboard + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The databases that are upstream of this dashboard + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.list_of(Datasource), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Datasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data sources that are upstream of this dashboard + + Arguments: + + * `filter` (`Datasource_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatasourceSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + DatasourcesConnection, + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Datasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data sources that are upstream of this dashboard + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Datasource_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields = sgqlc.types.Field( + sgqlc.types.list_of(Field), + graphql_name="upstreamFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The fields that are upstream of this dashboard + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="upstreamFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The fields that are upstream of this dashboard + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.list_of("Flow"), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are upstream of this dashboard + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are upstream of this dashboard + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_lenses = sgqlc.types.Field( + sgqlc.types.list_of(Lens), + graphql_name="upstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Lenses that are upstream of this dashboard + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_lenses_connection = sgqlc.types.Field( + LensesConnection, + graphql_name="upstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Lenses that are upstream of this dashboard + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_sheet_field_instances = sgqlc.types.Field( + sgqlc.types.list_of(Field), + graphql_name="upstreamSheetFieldInstances", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheet field instances used by the sheets referenced by this + dashboard + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_sheet_field_instances_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="upstreamSheetFieldInstancesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheet field instances used by the sheets referenced by this + dashboard + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.list_of(Table), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Table_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + TableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that are upstream of this dashboard + + Arguments: + + * `filter` (`Table_Filter`): Filter by GraphQL field and given + value + * `order_by` (`TableSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + TablesConnection, + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Table_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that are upstream of this dashboard + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Table_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class DataCloud( + sgqlc.types.Type, CanHaveLabels, Certifiable, Database, Taggable, Warnable +): + """A Data Cloud connection *Available in Tableau Cloud February + 2024 / Server 2024.2 and later.* + """ + + __schema__ = tableau_schema + __field_names__ = () + + +class DataQualityCertification(sgqlc.types.Type, Label): + """A data quality certification associated with a content item""" + + __schema__ = tableau_schema + __field_names__ = () + + +class DataQualityWarning(sgqlc.types.Type, Label): + """A data quality warning associated with a content item""" + + __schema__ = tableau_schema + __field_names__ = ("is_severe", "warning_type") + is_severe = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="isSevere" + ) + """Synonymous with isElevated""" + + warning_type = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="warningType" + ) + """Synonymous with value""" + + +class DatabaseServer( + sgqlc.types.Type, CanHaveLabels, Certifiable, Database, Taggable, Warnable +): + """A database server connection""" + + __schema__ = tableau_schema + __field_names__ = ("extended_connection_type", "host_name", "port", "service") + extended_connection_type = sgqlc.types.Field( + String, graphql_name="extendedConnectionType" + ) + """optional Extended Connection info for specific connection types, + eg hive for Cloudera Hadoop + """ + + host_name = sgqlc.types.Field(String, graphql_name="hostName") + """Hostname of the database""" + + port = sgqlc.types.Field(Int, graphql_name="port") + """Port number of the database connection""" + + service = sgqlc.types.Field(String, graphql_name="service") + """service string for certain datasources eg Oracle""" + + +class DatabaseTable( + sgqlc.types.Type, CanHaveLabels, Certifiable, Table, Taggable, Warnable +): + """A table that is contained in a database""" + + __schema__ = tableau_schema + __field_names__ = ( + "additional_details", + "certification_note", + "certifier", + "connection_type", + "contact", + "database", + "downstream_metric_definitions", + "downstream_metric_definitions_connection", + "full_name", + "project_name", + "project_vizportal_url_id", + "referenced_by_queries", + "referenced_by_queries_connection", + "schema", + "table_type", + "upstream_data_quality_warnings", + "upstream_data_quality_warnings_connection", + "upstream_labels", + "upstream_labels_connection", + "vizportal_id", + ) + additional_details = sgqlc.types.Field( + TableAdditionalDetails, graphql_name="additionalDetails" + ) + """Additional details regarding this table""" + + certification_note = sgqlc.types.Field(String, graphql_name="certificationNote") + """Notes related to the database table being marked as certified""" + + certifier = sgqlc.types.Field(TableauUser, graphql_name="certifier") + """User who marked this table as certified""" + + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type of parent database""" + + contact = sgqlc.types.Field(TableauUser, graphql_name="contact") + """Contact for this table""" + + database = sgqlc.types.Field(Database, graphql_name="database") + """The database to which this table belongs""" + + downstream_metric_definitions = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(MetricDefinition)), + graphql_name="downstreamMetricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this databaseTable. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions_connection = sgqlc.types.Field( + MetricDefinitionsConnection, + graphql_name="downstreamMetricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this databaseTable. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + full_name = sgqlc.types.Field(String, graphql_name="fullName") + """Fully qualified table name""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the table is visible. Will be + empty if the table is not in a project. + """ + + project_vizportal_url_id = sgqlc.types.Field( + String, graphql_name="projectVizportalUrlId" + ) + """The ID of the project in which the table is visible. Will be empty + if the table is not in a project. + """ + + referenced_by_queries = sgqlc.types.Field( + sgqlc.types.list_of(CustomSQLTable), + graphql_name="referencedByQueries", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CustomSQLTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CustomSQLTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The custom SQL queries that reference this table + + Arguments: + + * `filter` (`CustomSQLTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CustomSQLTableSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + referenced_by_queries_connection = sgqlc.types.Field( + CustomSQLTablesConnection, + graphql_name="referencedByQueriesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CustomSQLTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CustomSQLTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The custom SQL queries that reference this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CustomSQLTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CustomSQLTableSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + schema = sgqlc.types.Field(String, graphql_name="schema") + """Name of table schema. Note: For some databases, such as + Amazon Athena and Exasol, the schema attribute may not return the + correct schema name for the table. For more information, see + https://help.tableau.com/current/api/metadata_api/en- + us/docs/meta_api_model.html#schema_attribute. + """ + + table_type = sgqlc.types.Field( + sgqlc.types.non_null(TableType), graphql_name="tableType" + ) + """Type of the table""" + + upstream_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(DataQualityWarning)) + ), + graphql_name="upstreamDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this table + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings_connection = sgqlc.types.Field( + DataQualityWarningsConnection, + graphql_name="upstreamDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this table + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this table. Available in Tableau Cloud March + 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + LabelsConnection, + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this table. Available in Tableau Cloud March + 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + vizportal_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalId" + ) + """Vizportal ID of this table, for use in client-to-server + communications + """ + + +class DatasourceField(sgqlc.types.Type, Field, Node): + """GraphQL type for a data source field. Data source fields can only + exist in embedded data sources which connect to a published data + source. A data source field is an embedded data source's 'layered' + representation of a field that already exists in the published + data source and is mostly a copy of the field in the published + data source. Data source fields can get their own descriptions and + renames local to the embedded data source, but cannot otherwise be + modified in the embedded data source. + """ + + __schema__ = tableau_schema + __field_names__ = ("remote_field",) + remote_field = sgqlc.types.Field(Field, graphql_name="remoteField") + """Reference to a field from a published data source. This property + only exists on Fields that are in an embedded data source with a + connection to a published data source. + """ + + +class EmbeddedDatasource(sgqlc.types.Type, Datasource): + """A data source embedded in a workbook""" + + __schema__ = tableau_schema + __field_names__ = ( + "downstream_flows", + "downstream_flows_connection", + "parent_published_datasources", + "parent_published_datasources_connection", + "upstream_data_quality_warnings", + "upstream_data_quality_warnings_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_labels", + "upstream_labels_connection", + "workbook", + ) + downstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="downstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream from this data source + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="downstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parent_published_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="parentPublishedDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Parent published data sources of this embedded data source + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parent_published_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="parentPublishedDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Parent published data sources of this embedded data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(DataQualityWarning)) + ), + graphql_name="upstreamDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this data source + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings_connection = sgqlc.types.Field( + DataQualityWarningsConnection, + graphql_name="upstreamDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream from this data source + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream from this data source + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this data source. Available in Tableau Cloud + March 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + LabelsConnection, + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this data source. Available in Tableau Cloud + March 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + workbook = sgqlc.types.Field("Workbook", graphql_name="workbook") + """Workbook that contains these embedded datasources""" + + +class File(sgqlc.types.Type, CanHaveLabels, Certifiable, Database, Taggable, Warnable): + """A file connection""" + + __schema__ = tableau_schema + __field_names__ = ("file_path",) + file_path = sgqlc.types.Field(String, graphql_name="filePath") + """Path to file""" + + +class Flow(sgqlc.types.Type, CanHaveLabels, Taggable, Warnable): + """Flows are used to prepare data, which can include aggregation, + cleaning, preprocessing, etc. + """ + + __schema__ = tableau_schema + __field_names__ = ( + "container_name", + "container_type", + "contains_unsupported_custom_sql", + "created_at", + "description", + "downstream_dashboards", + "downstream_dashboards_connection", + "downstream_databases", + "downstream_databases_connection", + "downstream_datasources", + "downstream_datasources_connection", + "downstream_flows", + "downstream_flows_connection", + "downstream_lenses", + "downstream_lenses_connection", + "downstream_linked_flows", + "downstream_linked_flows_connection", + "downstream_metric_definitions", + "downstream_metric_definitions_connection", + "downstream_metrics", + "downstream_metrics_connection", + "downstream_owners", + "downstream_owners_connection", + "downstream_sheets", + "downstream_sheets_connection", + "downstream_tables", + "downstream_tables_connection", + "downstream_virtual_connection_tables", + "downstream_virtual_connection_tables_connection", + "downstream_virtual_connections", + "downstream_virtual_connections_connection", + "downstream_workbooks", + "downstream_workbooks_connection", + "input_fields", + "input_fields_connection", + "next_downstream_flows", + "next_downstream_flows_connection", + "next_upstream_flows", + "next_upstream_flows_connection", + "output_fields", + "output_fields_connection", + "output_steps", + "output_steps_connection", + "owner", + "personal_space_url_link", + "project_name", + "project_vizportal_url_id", + "site", + "updated_at", + "upstream_data_quality_warnings", + "upstream_data_quality_warnings_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_labels", + "upstream_labels_connection", + "upstream_linked_flows", + "upstream_linked_flows_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "upstream_virtual_connections", + "upstream_virtual_connections_connection", + "uri", + "vizportal_url_id", + ) + container_name = sgqlc.types.Field(String, graphql_name="containerName") + """The name of the container in which the flow is visible and usable. + Either a personal space or project. + """ + + container_type = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="containerType" + ) + """The type of the container in which the flow is visible and usable. + Either personal space or project. + """ + + contains_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="containsUnsupportedCustomSql" + ) + """True if the flow contains unsupported custom SQL, in which case + lineage may be incomplete + """ + + created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt") + """Time the flow was created. Available in Tableau Cloud June 2022 / + Server 2022.3 and later. + """ + + description = sgqlc.types.Field(String, graphql_name="description") + """Description of the flow""" + + downstream_dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Dashboard))), + graphql_name="downstreamDashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards that are downstream from this flow + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards_connection = sgqlc.types.Field( + DashboardsConnection, + graphql_name="downstreamDashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards that are downstream from this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="downstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are downstream from this flow. + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="downstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are downstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="downstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Published Data Sources that are downstream from this flow. + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="downstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Published Data Sources that are downstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="downstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are downstream from this flow. + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="downstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are downstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Lens))), + graphql_name="downstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses that are downstream from this flow + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses_connection = sgqlc.types.Field( + LensesConnection, + graphql_name="downstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses that are downstream from this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_linked_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LinkedFlow))), + graphql_name="downstreamLinkedFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + LinkedFlow_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + LinkedFlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Linked flows that are downstream from this flow. + + Arguments: + + * `filter` (`LinkedFlow_Filter`): Filter by GraphQL field and + given value + * `order_by` (`LinkedFlowSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_linked_flows_connection = sgqlc.types.Field( + LinkedFlowsConnection, + graphql_name="downstreamLinkedFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + LinkedFlow_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LinkedFlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Linked flows that are downstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`LinkedFlow_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LinkedFlowSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(MetricDefinition)), + graphql_name="downstreamMetricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this flow. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions_connection = sgqlc.types.Field( + MetricDefinitionsConnection, + graphql_name="downstreamMetricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Metric"))), + graphql_name="downstreamMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics that are downstream from this flow + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics_connection = sgqlc.types.Field( + MetricsConnection, + graphql_name="downstreamMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics that are downstream from this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_owners = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(TableauUser))), + graphql_name="downstreamOwners", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners that are downstream from this flow + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_owners_connection = sgqlc.types.Field( + TableauUsersConnection, + graphql_name="downstreamOwnersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners that are downstream from this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Sheet"))), + graphql_name="downstreamSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that are downstream from this flow + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_sheets_connection = sgqlc.types.Field( + SheetsConnection, + graphql_name="downstreamSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets that are downstream from this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(DatabaseTable))), + graphql_name="downstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are downstream from this flow. + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="downstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are downstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="downstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnectionTables that are downstream of this flow + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables_connection = sgqlc.types.Field( + VirtualConnectionTablesConnection, + graphql_name="downstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnectionTables that are downstream of this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="downstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnections that are downstream of this flow + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections_connection = sgqlc.types.Field( + VirtualConnectionsConnection, + graphql_name="downstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnections that are downstream of this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Workbook"))), + graphql_name="downstreamWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks that are downstream from this flow + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks_connection = sgqlc.types.Field( + WorkbooksConnection, + graphql_name="downstreamWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks that are downstream from this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + input_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FlowInputField))), + graphql_name="inputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowInputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowInputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields that are inputs to this flow + + Arguments: + + * `filter` (`FlowInputField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`FlowInputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + input_fields_connection = sgqlc.types.Field( + FlowInputFieldsConnection, + graphql_name="inputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowInputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowInputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields that are inputs to this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowInputField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowInputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + next_downstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="nextDownstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are next immediate downstream from this flow. + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + next_downstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="nextDownstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are next immediate downstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + next_upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of("Flow")), + graphql_name="nextUpstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are next immediate upstream from this flow. + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + next_upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="nextUpstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are next immediate upstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + output_fields = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(FlowOutputField)) + ), + graphql_name="outputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields that are outputs of this flow + + Arguments: + + * `filter` (`FlowOutputField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`FlowOutputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + output_fields_connection = sgqlc.types.Field( + FlowOutputFieldsConnection, + graphql_name="outputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields that are outputs of this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowOutputField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowOutputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + output_steps = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FlowOutputStep))), + graphql_name="outputSteps", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowOutputStep_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputStepSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Output steps for this flow + + Arguments: + + * `filter` (`FlowOutputStep_Filter`): Filter by GraphQL field and + given value + * `order_by` (`FlowOutputStepSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + output_steps_connection = sgqlc.types.Field( + FlowOutputStepsConnection, + graphql_name="outputStepsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowOutputStep_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputStepSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Output steps for this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowOutputStep_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowOutputStepSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owner = sgqlc.types.Field(TableauUser, graphql_name="owner") + """User who owns this flow""" + + personal_space_url_link = sgqlc.types.Field( + String, graphql_name="personalSpaceUrlLink" + ) + """The link to the personal space in which the flow is visible and + usable. Will be null if the flow is not in a personal space. + """ + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the flow is visible and usable""" + + project_vizportal_url_id = sgqlc.types.Field( + String, graphql_name="projectVizportalUrlId" + ) + """The ID of the project in which the flow is visible and usable. + Will be null if the flow is not in a project. + """ + + site = sgqlc.types.Field(TableauSite, graphql_name="site") + """The site in which the flow is visible and usable""" + + updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt") + """Time the flow was updated. Available in Tableau Cloud June 2022 / + Server 2022.3 and later. + """ + + upstream_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(DataQualityWarning)) + ), + graphql_name="upstreamDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this flow + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings_connection = sgqlc.types.Field( + DataQualityWarningsConnection, + graphql_name="upstreamDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are upstream from this flow. + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are upstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources that are upstream from this flow. + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources that are upstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Flow"))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are upstream from this flow. + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows that are upstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this flow. Available in Tableau Cloud March + 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + LabelsConnection, + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this flow. Available in Tableau Cloud March + 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_linked_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(LinkedFlow))), + graphql_name="upstreamLinkedFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + LinkedFlow_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + LinkedFlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Linked flows that are upstream from this flow. + + Arguments: + + * `filter` (`LinkedFlow_Filter`): Filter by GraphQL field and + given value + * `order_by` (`LinkedFlowSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_linked_flows_connection = sgqlc.types.Field( + LinkedFlowsConnection, + graphql_name="upstreamLinkedFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + LinkedFlow_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LinkedFlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Linked flows that are upstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`LinkedFlow_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LinkedFlowSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(DatabaseTable))), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are upstream from this flow. + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables that are upstream from this flow. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of("VirtualConnectionTable")), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection table upstream to this Flow + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + VirtualConnectionTablesConnection, + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection table upstream to this Flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.list_of("VirtualConnection"), + graphql_name="upstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection upstream to this Flow + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections_connection = sgqlc.types.Field( + VirtualConnectionsConnection, + graphql_name="upstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection upstream to this Flow + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + uri = sgqlc.types.Field(String, graphql_name="uri") + """Locally unique identifier used for the REST API on the Tableau + Server + """ + + vizportal_url_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalUrlId" + ) + """VizPortal URL ID; used for URL generation""" + + +class FlowColumnInputField(sgqlc.types.Type, FlowInputField): + """Column input field implementation""" + + __schema__ = tableau_schema + __field_names__ = ("column", "field_id") + column = sgqlc.types.Field(Column, graphql_name="column") + """The underlying wrapped column""" + + field_id = sgqlc.types.Field(String, graphql_name="fieldId") + """Identifier internal to flow""" + + +class FlowColumnOutputField(sgqlc.types.Type, FlowOutputField): + """Column output field implementation""" + + __schema__ = tableau_schema + __field_names__ = ("column", "field_id") + column = sgqlc.types.Field(Column, graphql_name="column") + """The underlying wrapped column""" + + field_id = sgqlc.types.Field(String, graphql_name="fieldId") + """Identifier internal to flow""" + + +class FlowFieldInputField(sgqlc.types.Type, FlowInputField): + """Field input field implementation""" + + __schema__ = tableau_schema + __field_names__ = ("field", "field_id") + field = sgqlc.types.Field(Field, graphql_name="field") + """The underlying wrapped field""" + + field_id = sgqlc.types.Field(String, graphql_name="fieldId") + """Identifier internal to flow""" + + +class FlowFieldOutputField(sgqlc.types.Type, FlowOutputField): + """Field output field implementation""" + + __schema__ = tableau_schema + __field_names__ = ("field", "field_id") + field = sgqlc.types.Field(Field, graphql_name="field") + """The underlying wrapped field""" + + field_id = sgqlc.types.Field(String, graphql_name="fieldId") + """Identifier internal to flow""" + + +class GenericLabel(sgqlc.types.Type, Label): + """A label that can be attached to assets. *Available in Tableau + Cloud March 2023 / Server 2023.1 and later.* + """ + + __schema__ = tableau_schema + __field_names__ = () + + +class GroupField(sgqlc.types.Type, DataField, Field, FieldReferencingField, Node): + """GraphQL type for a group field. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/sortgroup_groups_creating.html + """ + + __schema__ = tableau_schema + __field_names__ = ("has_other",) + has_other = sgqlc.types.Field(Boolean, graphql_name="hasOther") + """Field has an 'Other' group. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/sortgroup_groups_creating.html#Include + """ + + +class HierarchyField(sgqlc.types.Type, Field, FieldReferencingField, Node): + """GraphQL type for a hierarchy. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/qs_hierarchies.html + """ + + __schema__ = tableau_schema + __field_names__ = () + + +class Metric(sgqlc.types.Type, Taggable): + """Metrics are time series data constructed from fields contained in + views. *Retired in Tableau Cloud February 2024 / Server 2024.2.* + """ + + __schema__ = tableau_schema + __field_names__ = ( + "container_name", + "container_type", + "created_at", + "description", + "owner", + "project_name", + "project_vizportal_url_id", + "site", + "underlying_view", + "updated_at", + "upstream_columns", + "upstream_columns_connection", + "upstream_data_quality_warnings", + "upstream_data_quality_warnings_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_fields", + "upstream_fields_connection", + "upstream_flow_column_output_fields", + "upstream_flow_column_output_fields_connection", + "upstream_flow_field_output_fields", + "upstream_flow_field_output_fields_connection", + "upstream_flow_output_fields", + "upstream_flow_output_fields_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_labels", + "upstream_labels_connection", + "upstream_lenses", + "upstream_lenses_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_workbooks", + "upstream_workbooks_connection", + "vizportal_url_id", + ) + container_name = sgqlc.types.Field(String, graphql_name="containerName") + """The name of the container in which the metric is visible and + usable. This is always a project. + """ + + container_type = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="containerType" + ) + """The type of the container in which the metric is visible and + usable. This is always a project. + """ + + created_at = sgqlc.types.Field( + sgqlc.types.non_null(DateTime), graphql_name="createdAt" + ) + """Time the Metric was created""" + + description = sgqlc.types.Field(String, graphql_name="description") + """Description of the Metric""" + + owner = sgqlc.types.Field(sgqlc.types.non_null(TableauUser), graphql_name="owner") + """User who owns this Metric""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the Metric is visible and usable.""" + + project_vizportal_url_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="projectVizportalUrlId" + ) + """The ID of the project in which the Metric is visible and usable.""" + + site = sgqlc.types.Field(sgqlc.types.non_null(TableauSite), graphql_name="site") + """The site in which the Metric is visible and usable""" + + underlying_view = sgqlc.types.Field(View, graphql_name="underlyingView") + """The original View off of which the Metric is based""" + + updated_at = sgqlc.types.Field( + sgqlc.types.non_null(DateTime), graphql_name="updatedAt" + ) + """Time the Metric was last updated""" + + upstream_columns = sgqlc.types.Field( + sgqlc.types.list_of(Column), + graphql_name="upstreamColumns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Columns that are upstream of this metric + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_columns_connection = sgqlc.types.Field( + ColumnsConnection, + graphql_name="upstreamColumnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Columns that are upstream of this metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(DataQualityWarning)) + ), + graphql_name="upstreamDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this Metric + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings_connection = sgqlc.types.Field( + DataQualityWarningsConnection, + graphql_name="upstreamDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this Metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.list_of(Database), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are upstream of this metric + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases that are upstream of this metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.list_of("PublishedDatasource"), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Published Datasources that are upstream to this Metric + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Published Datasources that are upstream to this Metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields = sgqlc.types.Field( + sgqlc.types.list_of(Field), + graphql_name="upstreamFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """fields that are upstream of this metric + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="upstreamFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """fields that are upstream of this metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flow_column_output_fields = sgqlc.types.Field( + sgqlc.types.list_of(FlowColumnOutputField), + graphql_name="upstreamFlowColumnOutputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowColumnOutputField_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowColumnOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """OutputFields that are upstream of this Metric + + Arguments: + + * `filter` (`FlowColumnOutputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowColumnOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flow_column_output_fields_connection = sgqlc.types.Field( + FlowColumnOutputFieldsConnection, + graphql_name="upstreamFlowColumnOutputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowColumnOutputField_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowColumnOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """OutputFields that are upstream of this Metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowColumnOutputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowColumnOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flow_field_output_fields = sgqlc.types.Field( + sgqlc.types.list_of(FlowFieldOutputField), + graphql_name="upstreamFlowFieldOutputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """OutputFields that are upstream of this Metric + + Arguments: + + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flow_field_output_fields_connection = sgqlc.types.Field( + FlowFieldOutputFieldsConnection, + graphql_name="upstreamFlowFieldOutputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowFieldOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowFieldOutputFieldSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """OutputFields that are upstream of this Metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowFieldOutputField_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowFieldOutputFieldSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flow_output_fields = sgqlc.types.Field( + sgqlc.types.list_of(FlowOutputField), + graphql_name="upstreamFlowOutputFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + FlowOutputField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """OutputFields that are upstream of this Metric + + Arguments: + + * `filter` (`FlowOutputField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`FlowOutputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flow_output_fields_connection = sgqlc.types.Field( + FlowOutputFieldsConnection, + graphql_name="upstreamFlowOutputFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + FlowOutputField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowOutputFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """OutputFields that are upstream of this Metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`FlowOutputField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowOutputFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.list_of(Flow), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are upstream of this metric + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are upstream of this metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this Metric. Available in Tableau Cloud March + 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + LabelsConnection, + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this Metric. Available in Tableau Cloud March + 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_lenses = sgqlc.types.Field( + sgqlc.types.list_of(Lens), + graphql_name="upstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Lenses that are upstream of this workbook + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_lenses_connection = sgqlc.types.Field( + LensesConnection, + graphql_name="upstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Lenses that are upstream of this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(DatabaseTable)), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """tables that are upstream of this metric + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """tables that are upstream of this metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_workbooks = sgqlc.types.Field( + sgqlc.types.list_of("Workbook"), + graphql_name="upstreamWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks that are upstream of this metric + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_workbooks_connection = sgqlc.types.Field( + WorkbooksConnection, + graphql_name="upstreamWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks that are upstream of this metric + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + vizportal_url_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalUrlId" + ) + """VizPortal URL ID; used for URL generation""" + + +class PublishedDatasource( + sgqlc.types.Type, CanHaveLabels, Certifiable, Datasource, Taggable, Warnable +): + """A Tableau data source that has been published separately to + Tableau Server. It can be used by multiple workbooks. + """ + + __schema__ = tableau_schema + __field_names__ = ( + "certification_note", + "certifier", + "certifier_display_name", + "container_name", + "container_type", + "description", + "downstream_databases", + "downstream_databases_connection", + "downstream_datasources", + "downstream_datasources_connection", + "downstream_flows", + "downstream_flows_connection", + "downstream_lenses", + "downstream_lenses_connection", + "downstream_metric_definitions", + "downstream_metric_definitions_connection", + "downstream_metrics", + "downstream_metrics_connection", + "downstream_tables", + "downstream_tables_connection", + "downstream_virtual_connection_tables", + "downstream_virtual_connection_tables_connection", + "downstream_virtual_connections", + "downstream_virtual_connections_connection", + "owner", + "parameters", + "parameters_connection", + "project_name", + "project_vizportal_url_id", + "site", + "upstream_data_quality_warnings", + "upstream_data_quality_warnings_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_labels", + "upstream_labels_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "upstream_virtual_connections", + "upstream_virtual_connections_connection", + "uri", + "vizportal_id", + "vizportal_url_id", + ) + certification_note = sgqlc.types.Field(String, graphql_name="certificationNote") + """Notes related to the data source being marked as certified""" + + certifier = sgqlc.types.Field(TableauUser, graphql_name="certifier") + """User who marked this data source as certified""" + + certifier_display_name = sgqlc.types.Field( + String, graphql_name="certifierDisplayName" + ) + """Name of the user who marked this data source as certified""" + + container_name = sgqlc.types.Field(String, graphql_name="containerName") + """The name of the container in which the published data source is + visible and usable. Either a personal space or project. + """ + + container_type = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="containerType" + ) + """The type of the container in which the published data source is + visible and usable. Either personal space or project. + """ + + description = sgqlc.types.Field(String, graphql_name="description") + """Description of the datasource""" + + downstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="downstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases downstream from this data source + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="downstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="downstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources downstream from this data source + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="downstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Flow))), + graphql_name="downstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream from this data source + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="downstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(Lens)), + graphql_name="downstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses connected downstream from this field + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses_connection = sgqlc.types.Field( + LensesConnection, + graphql_name="downstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses connected downstream from this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(MetricDefinition)), + graphql_name="downstreamMetricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from the data source. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions_connection = sgqlc.types.Field( + MetricDefinitionsConnection, + graphql_name="downstreamMetricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from the data source. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Metric))), + graphql_name="downstreamMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics downstream from this data source + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics_connection = sgqlc.types.Field( + MetricsConnection, + graphql_name="downstreamMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(DatabaseTable))), + graphql_name="downstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables downstream from this data source + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="downstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="downstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream of this data source + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables_connection = sgqlc.types.Field( + VirtualConnectionTablesConnection, + graphql_name="downstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connection tables downstream of this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnection")) + ), + graphql_name="downstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections downstream from this data source + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connections_connection = sgqlc.types.Field( + VirtualConnectionsConnection, + graphql_name="downstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Virtual connections downstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owner = sgqlc.types.Field(sgqlc.types.non_null(TableauUser), graphql_name="owner") + """User who owns this data source""" + + parameters = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Parameter))), + graphql_name="parameters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of parameters, if any, used in this data source + + Arguments: + + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parameters_connection = sgqlc.types.Field( + ParametersConnection, + graphql_name="parametersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of parameters, if any, used in this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project that contains this published data source.""" + + project_vizportal_url_id = sgqlc.types.Field( + String, graphql_name="projectVizportalUrlId" + ) + """The ID of the project in which the published data source is + visible and usable. Will return null if the published data source + is not in a project. + """ + + site = sgqlc.types.Field(sgqlc.types.non_null(TableauSite), graphql_name="site") + """The site which contains this published data source""" + + upstream_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(DataQualityWarning)) + ), + graphql_name="upstreamDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this data source + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings_connection = sgqlc.types.Field( + DataQualityWarningsConnection, + graphql_name="upstreamDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("PublishedDatasource")) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream from this data source + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Flow))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream from this data source + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream from this data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this data source. Available in Tableau Cloud + March 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + LabelsConnection, + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this data source. Available in Tableau Cloud + March 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of("VirtualConnectionTable")), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection table upstream to this Datasource + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + VirtualConnectionTablesConnection, + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection table upstream to this Datasource + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of("VirtualConnection")), + graphql_name="upstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection upstream to this Datasource + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections_connection = sgqlc.types.Field( + VirtualConnectionsConnection, + graphql_name="upstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection upstream to this Datasource + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + uri = sgqlc.types.Field(String, graphql_name="uri") + """Uri of the datasource""" + + vizportal_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalId" + ) + """Vizportal ID of this published datasource, for use in client-to- + server communications + """ + + vizportal_url_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalUrlId" + ) + """VizPortal URL ID; used for URL generation""" + + +class SetField(sgqlc.types.Type, Field, FieldReferencingField, Node): + """GraphQL type for a set field. See + https://onlinehelp.tableau.com/current/pro/desktop/en- + us/sortgroup_sets_create.html + """ + + __schema__ = tableau_schema + __field_names__ = ("parameters", "parameters_connection") + parameters = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Parameter))), + graphql_name="parameters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of parameters, if any, used in this field + + Arguments: + + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parameters_connection = sgqlc.types.Field( + ParametersConnection, + graphql_name="parametersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """List of parameters, if any, used in this field + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class Sheet(sgqlc.types.Type, Taggable, View): + """A sheet contained in a published workbook.""" + + __schema__ = tableau_schema + __field_names__ = ( + "contained_in_dashboards", + "contained_in_dashboards_connection", + "datasource_fields", + "datasource_fields_connection", + "parent_embedded_datasources", + "parent_embedded_datasources_connection", + "sheet_field_instances", + "sheet_field_instances_connection", + "upstream_columns", + "upstream_columns_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_fields", + "upstream_fields_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_tables", + "upstream_tables_connection", + "worksheet_fields", + "worksheet_fields_connection", + ) + contained_in_dashboards = sgqlc.types.Field( + sgqlc.types.list_of(Dashboard), + graphql_name="containedInDashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards that contain this sheet + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + contained_in_dashboards_connection = sgqlc.types.Field( + DashboardsConnection, + graphql_name="containedInDashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards that contain this sheet + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + datasource_fields = sgqlc.types.Field( + sgqlc.types.list_of(Field), + graphql_name="datasourceFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields that are contained in an embedded data source and are also + referenced by the worksheet. If a worksheet uses calculated fields + (or any other FieldReferencingField), this list will also include + all of the referenced fields. + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + datasource_fields_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="datasourceFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Fields that are contained in an embedded data source and are also + referenced by the worksheet. If a worksheet uses calculated fields + (or any other FieldReferencingField), this list will also include + all of the referenced fields. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parent_embedded_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(EmbeddedDatasource)) + ), + graphql_name="parentEmbeddedDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + EmbeddedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + EmbeddedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Parent embedded data source of this sheet + + Arguments: + + * `filter` (`EmbeddedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`EmbeddedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parent_embedded_datasources_connection = sgqlc.types.Field( + EmbeddedDatasourcesConnection, + graphql_name="parentEmbeddedDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + EmbeddedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + EmbeddedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Parent embedded data source of this sheet + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`EmbeddedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`EmbeddedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheet_field_instances = sgqlc.types.Field( + sgqlc.types.list_of(Field), + graphql_name="sheetFieldInstances", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """All fields in the collection worksheetFields as well as the fields + in datasourceFields used directly by this sheet. If the worksheet + uses calculated fields this list will not include referenced + fields that are not directly used by the sheet. + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheet_field_instances_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="sheetFieldInstancesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """All fields in the collection worksheetFields as well as the fields + in datasourceFields used directly by this sheet. If the worksheet + uses calculated fields this list will not include referenced + fields that are not directly used by the sheet. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_columns = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(Column)), + graphql_name="upstreamColumns", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The columns that are upstream of this sheet + + Arguments: + + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_columns_connection = sgqlc.types.Field( + ColumnsConnection, + graphql_name="upstreamColumnsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Column_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ColumnSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The columns that are upstream of this sheet + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Column_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ColumnSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.list_of(Database), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The databases that are upstream of this sheet + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The databases that are upstream of this sheet + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.list_of(Datasource), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Datasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatasourceSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data sources that are upstream of this sheet + + Arguments: + + * `filter` (`Datasource_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatasourceSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + DatasourcesConnection, + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Datasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatasourceSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The data sources that are upstream of this sheet + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Datasource_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatasourceSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(Field)), + graphql_name="upstreamFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The fields that are upstream of this sheet + + Arguments: + + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_fields_connection = sgqlc.types.Field( + FieldsConnection, + graphql_name="upstreamFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Field_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The fields that are upstream of this sheet + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Field_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FieldSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.list_of(Flow), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are upstream of this sheet + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are upstream of this sheet + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.list_of(Table), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Table_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + TableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that are upstream of this sheet + + Arguments: + + * `filter` (`Table_Filter`): Filter by GraphQL field and given + value + * `order_by` (`TableSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + TablesConnection, + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Table_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables that are upstream of this sheet + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Table_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + worksheet_fields = sgqlc.types.Field( + sgqlc.types.list_of(CalculatedField), + graphql_name="worksheetFields", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Calculated fields which were created on this sheet, e.g. in the + rows or columns shelves and which may not be used on other sheets + that use this embedded data source + + Arguments: + + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + worksheet_fields_connection = sgqlc.types.Field( + CalculatedFieldsConnection, + graphql_name="worksheetFieldsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + CalculatedField_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + CalculatedFieldSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Calculated fields which were created on this sheet, e.g. in the + rows or columns shelves and which may not be used on other sheets + that use this embedded data source + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`CalculatedField_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`CalculatedFieldSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + +class VirtualConnection( + sgqlc.types.relay.Connection, CanHaveLabels, Certifiable, Taggable, Warnable +): + """A virtual connection. *Available in Tableau Cloud March 2022 / + Server 2022.1 and later.* + """ + + __schema__ = tableau_schema + __field_names__ = ( + "connection_type", + "container_name", + "container_type", + "created_at", + "description", + "downstream_dashboards", + "downstream_dashboards_connection", + "downstream_datasources", + "downstream_datasources_connection", + "downstream_flows", + "downstream_flows_connection", + "downstream_lenses", + "downstream_lenses_connection", + "downstream_metric_definitions", + "downstream_metric_definitions_connection", + "downstream_metrics", + "downstream_metrics_connection", + "downstream_owners", + "downstream_owners_connection", + "downstream_sheets", + "downstream_sheets_connection", + "downstream_virtual_connection_tables", + "downstream_virtual_connection_tables_connection", + "downstream_workbooks", + "downstream_workbooks_connection", + "owner", + "project_name", + "project_vizportal_url_id", + "site", + "tables", + "tables_connection", + "updated_at", + "upstream_data_quality_warnings", + "upstream_data_quality_warnings_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_labels", + "upstream_labels_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "uri", + "vizportal_id", + "vizportal_url_id", + ) + connection_type = sgqlc.types.Field(String, graphql_name="connectionType") + """Connection type of this virtual connection""" + + container_name = sgqlc.types.Field(String, graphql_name="containerName") + """The name of the container in which the virtual connection is + visible and usable. Either a personal space or project. + """ + + container_type = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="containerType" + ) + """The type of the container in which the virtual connection is + visible and usable. Either personal space or project. + """ + + created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt") + """Time the Virtual Connection was created. Available in Tableau + Cloud June 2022 / Server 2022.3 and later. + """ + + description = sgqlc.types.Field(String, graphql_name="description") + """User modifiable description of this virtual connection""" + + downstream_dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Dashboard))), + graphql_name="downstreamDashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards downstream of this virtual connection + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_dashboards_connection = sgqlc.types.Field( + DashboardsConnection, + graphql_name="downstreamDashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards downstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(PublishedDatasource)) + ), + graphql_name="downstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Published Data Sources downstream of this virtual connection + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="downstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Published Data Sources downstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Flow))), + graphql_name="downstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream of this virtual connection + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="downstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows downstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Lens))), + graphql_name="downstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses downstream of this published connection + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_lenses_connection = sgqlc.types.Field( + LensesConnection, + graphql_name="downstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Lenses downstream of this published connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions = sgqlc.types.Field( + sgqlc.types.list_of(MetricDefinition), + graphql_name="downstreamMetricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this VirtualConnection. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions_connection = sgqlc.types.Field( + MetricDefinitionsConnection, + graphql_name="downstreamMetricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this VirtualConnection. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Metric))), + graphql_name="downstreamMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics downstream of this virtual connection + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics_connection = sgqlc.types.Field( + MetricsConnection, + graphql_name="downstreamMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics downstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_owners = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(TableauUser))), + graphql_name="downstreamOwners", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners connected to the database + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_owners_connection = sgqlc.types.Field( + TableauUsersConnection, + graphql_name="downstreamOwnersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Owners connected to the database + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Sheet))), + graphql_name="downstreamSheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets downstream of this virtual connection + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_sheets_connection = sgqlc.types.Field( + SheetsConnection, + graphql_name="downstreamSheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Sheets downstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="downstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnectionTables downstream of this virtual connection + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_virtual_connection_tables_connection = sgqlc.types.Field( + VirtualConnectionTablesConnection, + graphql_name="downstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """VirtualConnectionTables downstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Workbook"))), + graphql_name="downstreamWorkbooks", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks downstream of this virtual connection + + Arguments: + + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_workbooks_connection = sgqlc.types.Field( + WorkbooksConnection, + graphql_name="downstreamWorkbooksConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Workbook_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + WorkbookSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Workbooks downstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Workbook_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`WorkbookSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owner = sgqlc.types.Field(sgqlc.types.non_null(TableauUser), graphql_name="owner") + """User who owns this virtual connection""" + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project that contains this virtual connection.""" + + project_vizportal_url_id = sgqlc.types.Field( + String, graphql_name="projectVizportalUrlId" + ) + """The ID of the project in which the virtual connection is visible + and usable. Will return null if the published virtual connection + is not in a project. + """ + + site = sgqlc.types.Field(sgqlc.types.non_null(TableauSite), graphql_name="site") + """The site which contains this virtual connection""" + + tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="tables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables exposed by this virtual connection + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + tables_connection = sgqlc.types.Field( + VirtualConnectionTablesConnection, + graphql_name="tablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables exposed by this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt") + """Time the Virtual Connection was last updated. Available in Tableau + Cloud June 2022 / Server 2022.3 and later. + """ + + upstream_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(DataQualityWarning)) + ), + graphql_name="upstreamDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this virtual connection + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings_connection = sgqlc.types.Field( + DataQualityWarningsConnection, + graphql_name="upstreamDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Database))), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream of this virtual connection + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Databases upstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(PublishedDatasource)) + ), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream of this virtual connection + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Datasources upstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Flow))), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream of this virtual connection + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Flows upstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this virtual connection. Available in Tableau + Cloud March 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + LabelsConnection, + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this virtual connection. Available in Tableau + Cloud March 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(DatabaseTable))), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream of this virtual connection + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Tables upstream of this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null("VirtualConnectionTable")) + ), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection tables that are upstream to this virtual + connection + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + VirtualConnectionTablesConnection, + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection tables that are upstream to this virtual + connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + uri = sgqlc.types.Field(String, graphql_name="uri") + """Uri of the virtual connection""" + + vizportal_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalId" + ) + """Vizportal ID of this table, for use in client-to-server + communications + """ + + vizportal_url_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalUrlId" + ) + """Vizportal URL ID; used for URL generation""" + + +class VirtualConnectionTable( + sgqlc.types.Type, CanHaveLabels, Certifiable, Table, Taggable, Warnable +): + """A table in a virtual connection. *Available in Tableau Cloud + March 2022 / Server 2022.1 and later.* + """ + + __schema__ = tableau_schema + __field_names__ = ( + "contains_unsupported_custom_sql", + "downstream_metric_definitions", + "downstream_metric_definitions_connection", + "extract_last_refresh_type", + "extract_last_refreshed_at", + "is_extracted", + "owner", + "upstream_data_quality_warnings", + "upstream_data_quality_warnings_connection", + "upstream_labels", + "upstream_labels_connection", + "uri", + "virtual_connection", + "vizportal_id", + "vizportal_url_id", + ) + contains_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="containsUnsupportedCustomSql" + ) + """True if the datasource contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + downstream_metric_definitions = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(MetricDefinition)), + graphql_name="downstreamMetricDefinitions", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this virtualConnectionTable. + + Arguments: + + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metric_definitions_connection = sgqlc.types.Field( + MetricDefinitionsConnection, + graphql_name="downstreamMetricDefinitionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + MetricDefinition_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricDefinitionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metric definitions downstream from this virtualConnectionTable. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`MetricDefinition_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricDefinitionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + extract_last_refresh_type = sgqlc.types.Field( + ExtractType, graphql_name="extractLastRefreshType" + ) + """The type of this table's last extract refresh (incremental or + full). + """ + + extract_last_refreshed_at = sgqlc.types.Field( + DateTime, graphql_name="extractLastRefreshedAt" + ) + """The time the data for this table's extract was refreshed.""" + + is_extracted = sgqlc.types.Field(Boolean, graphql_name="isExtracted") + """Whether or not queries to this table are using an extract.""" + + owner = sgqlc.types.Field(sgqlc.types.non_null(TableauUser), graphql_name="owner") + """User who owns this virtual connection table""" + + upstream_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(DataQualityWarning)) + ), + graphql_name="upstreamDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this virtual connection + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings_connection = sgqlc.types.Field( + DataQualityWarningsConnection, + graphql_name="upstreamDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this virtual connection + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this virtual connection. Available in Tableau + Cloud March 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + LabelsConnection, + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this virtual connection. Available in Tableau + Cloud March 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + uri = sgqlc.types.Field(String, graphql_name="uri") + """Uri of the virtual connection table""" + + virtual_connection = sgqlc.types.Field( + VirtualConnection, graphql_name="virtualConnection" + ) + """The parent virtual connection for this table""" + + vizportal_id = sgqlc.types.Field(String, graphql_name="vizportalId") + """Vizportal ID of this column, for use in client-to-server + communications + """ + + vizportal_url_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalUrlId" + ) + """VizPortal URL ID; used for URL generation""" + + +class WebDataConnector( + sgqlc.types.Type, CanHaveLabels, Certifiable, Database, Taggable, Warnable +): + """A web data connector""" + + __schema__ = tableau_schema + __field_names__ = ("connector_url",) + connector_url = sgqlc.types.Field(String, graphql_name="connectorUrl") + """The url for the sign-in page of the web data connector""" + + +class Workbook(sgqlc.types.Type, Taggable): + """Workbooks are used to package up Tableau visualizations (which are + called "sheets" in the Metadata API) and data models (which are + called "embedded data sources" when they are owned by a workbook). + """ + + __schema__ = tableau_schema + __field_names__ = ( + "container_name", + "container_type", + "contains_unsupported_custom_sql", + "created_at", + "dashboards", + "dashboards_connection", + "description", + "downstream_metrics", + "downstream_metrics_connection", + "downstream_owners", + "downstream_owners_connection", + "embedded_datasources", + "embedded_datasources_connection", + "owner", + "parameters", + "parameters_connection", + "project_luid", + "project_name", + "project_vizportal_url_id", + "sheets", + "sheets_connection", + "site", + "updated_at", + "upstream_data_quality_warnings", + "upstream_data_quality_warnings_connection", + "upstream_databases", + "upstream_databases_connection", + "upstream_datasources", + "upstream_datasources_connection", + "upstream_flows", + "upstream_flows_connection", + "upstream_labels", + "upstream_labels_connection", + "upstream_lenses", + "upstream_lenses_connection", + "upstream_tables", + "upstream_tables_connection", + "upstream_virtual_connection_tables", + "upstream_virtual_connection_tables_connection", + "upstream_virtual_connections", + "upstream_virtual_connections_connection", + "uri", + "views", + "views_connection", + "vizportal_url_id", + ) + container_name = sgqlc.types.Field(String, graphql_name="containerName") + """The name of the container in which the workbook is visible and + usable. Either a personal space or project. + """ + + container_type = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="containerType" + ) + """The type of the container in which the workbook is visible and + usable. Either personal space or project. + """ + + contains_unsupported_custom_sql = sgqlc.types.Field( + Boolean, graphql_name="containsUnsupportedCustomSql" + ) + """True if the workbook contains unsupported custom SQL, in which + case lineage may be incomplete + """ + + created_at = sgqlc.types.Field( + sgqlc.types.non_null(DateTime), graphql_name="createdAt" + ) + """Time the workbook was created""" + + dashboards = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Dashboard))), + graphql_name="dashboards", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards that are contained in this workbook + + Arguments: + + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + dashboards_connection = sgqlc.types.Field( + DashboardsConnection, + graphql_name="dashboardsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Dashboard_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DashboardSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Dashboards that are contained in this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Dashboard_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DashboardSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + description = sgqlc.types.Field(String, graphql_name="description") + """Description of the workbook""" + + downstream_metrics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Metric))), + graphql_name="downstreamMetrics", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics downstream from this workbook + + Arguments: + + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_metrics_connection = sgqlc.types.Field( + MetricsConnection, + graphql_name="downstreamMetricsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Metric_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + MetricSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Metrics downstream from this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Metric_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`MetricSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + downstream_owners = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(TableauUser))), + graphql_name="downstreamOwners", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Metric owners downstream from this workbook + + Arguments: + + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + downstream_owners_connection = sgqlc.types.Field( + TableauUsersConnection, + graphql_name="downstreamOwnersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + TableauUser_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + TableauUserSortOrder, graphql_name="orderBy", default=None + ), + ), + ) + ), + ) + """Metric owners downstream from this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`TableauUser_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`TableauUserSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + """ + + embedded_datasources = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(EmbeddedDatasource)) + ), + graphql_name="embeddedDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + EmbeddedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + EmbeddedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data sources that are embedded in this workbook + + Arguments: + + * `filter` (`EmbeddedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`EmbeddedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + embedded_datasources_connection = sgqlc.types.Field( + EmbeddedDatasourcesConnection, + graphql_name="embeddedDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + EmbeddedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + EmbeddedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data sources that are embedded in this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`EmbeddedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`EmbeddedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + owner = sgqlc.types.Field(sgqlc.types.non_null(TableauUser), graphql_name="owner") + """User who owns this workbook""" + + parameters = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Parameter))), + graphql_name="parameters", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Parameters that are contained in this workbook + + Arguments: + + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + parameters_connection = sgqlc.types.Field( + ParametersConnection, + graphql_name="parametersConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Parameter_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ParameterSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Parameters that are contained in this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Parameter_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ParameterSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + project_luid = sgqlc.types.Field(String, graphql_name="projectLuid") + """The luid of the project in which the workbook is visible and + usable. Available in Tableau Cloud June 2022 / Server 2022.3 and + later. + """ + + project_name = sgqlc.types.Field(String, graphql_name="projectName") + """The name of the project in which the workbook is visible and + usable. + """ + + project_vizportal_url_id = sgqlc.types.Field( + String, graphql_name="projectVizportalUrlId" + ) + """The ID of the project in which the workbook is visible and usable. + Will be null if the workbook is not in a project. + """ + + sheets = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Sheet))), + graphql_name="sheets", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Worksheets that are contained in this workbook + + Arguments: + + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + sheets_connection = sgqlc.types.Field( + SheetsConnection, + graphql_name="sheetsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Sheet_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SheetSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Worksheets that are contained in this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Sheet_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`SheetSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + site = sgqlc.types.Field(sgqlc.types.non_null(TableauSite), graphql_name="site") + """The site in which the workbook is visible and usable""" + + updated_at = sgqlc.types.Field( + sgqlc.types.non_null(DateTime), graphql_name="updatedAt" + ) + """Time the workbook was updated""" + + upstream_data_quality_warnings = sgqlc.types.Field( + sgqlc.types.non_null( + sgqlc.types.list_of(sgqlc.types.non_null(DataQualityWarning)) + ), + graphql_name="upstreamDataQualityWarnings", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this workbook + + Arguments: + + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_data_quality_warnings_connection = sgqlc.types.Field( + DataQualityWarningsConnection, + graphql_name="upstreamDataQualityWarningsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DataQualityWarning_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DataQualityWarningSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Data quality warnings upstream from this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DataQualityWarning_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DataQualityWarningSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(Database)), + graphql_name="upstreamDatabases", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Databases that are upstream to this Workbook + + Arguments: + + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_databases_connection = sgqlc.types.Field( + DatabasesConnection, + graphql_name="upstreamDatabasesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + Database_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Databases that are upstream to this Workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Database_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(PublishedDatasource)), + graphql_name="upstreamDatasources", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Published Datasources that are upstream to this Workbook + + Arguments: + + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_datasources_connection = sgqlc.types.Field( + PublishedDatasourcesConnection, + graphql_name="upstreamDatasourcesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + PublishedDatasource_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + PublishedDatasourceSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Published Datasources that are upstream to this Workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`PublishedDatasource_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`PublishedDatasourceSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows = sgqlc.types.Field( + sgqlc.types.list_of(Flow), + graphql_name="upstreamFlows", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are upstream of this workbook + + Arguments: + + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_flows_connection = sgqlc.types.Field( + FlowsConnection, + graphql_name="upstreamFlowsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Flow_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + FlowSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The flows that are upstream of this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Flow_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`FlowSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Label))), + graphql_name="upstreamLabels", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this workbook. Available in Tableau Cloud + March 2023 / Server 2023.1 and later. + + Arguments: + + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_labels_connection = sgqlc.types.Field( + LabelsConnection, + graphql_name="upstreamLabelsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Label_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LabelSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Labels upstream from this workbook. Available in Tableau Cloud + March 2023 / Server 2023.1 and later. + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Label_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LabelSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_lenses = sgqlc.types.Field( + sgqlc.types.list_of(Lens), + graphql_name="upstreamLenses", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Lenses that are upstream of this workbook + + Arguments: + + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_lenses_connection = sgqlc.types.Field( + LensesConnection, + graphql_name="upstreamLensesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(Lens_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + LensSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The Lenses that are upstream of this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`Lens_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`LensSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(DatabaseTable)), + graphql_name="upstreamTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables upstream to this Workbook + + Arguments: + + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_tables_connection = sgqlc.types.Field( + DatabaseTablesConnection, + graphql_name="upstreamTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + DatabaseTable_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DatabaseTableSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The tables upstream to this Workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`DatabaseTable_Filter`): Filter by GraphQL field and + given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`DatabaseTableSortOrder`): Sort by given fields. The + sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(VirtualConnectionTable)), + graphql_name="upstreamVirtualConnectionTables", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection table upstream to this Workbook + + Arguments: + + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connection_tables_connection = sgqlc.types.Field( + VirtualConnectionTablesConnection, + graphql_name="upstreamVirtualConnectionTablesConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnectionTable_Filter, + graphql_name="filter", + default=None, + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionTableSortOrder, + graphql_name="orderBy", + default=None, + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection table upstream to this Workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnectionTable_Filter`): Filter by GraphQL + field and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionTableSortOrder`): Sort by given + fields. The sort orders defined first in the list will take + priority. If there are no given sort orders or a tie on the + final sorted field then the resulting set will be sorted by ID + in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(VirtualConnection)), + graphql_name="upstreamVirtualConnections", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection upstream to this Workbook + + Arguments: + + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + upstream_virtual_connections_connection = sgqlc.types.Field( + VirtualConnectionsConnection, + graphql_name="upstreamVirtualConnectionsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg( + VirtualConnection_Filter, graphql_name="filter", default=None + ), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + VirtualConnectionSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """The virtual connection upstream to this Workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`VirtualConnection_Filter`): Filter by GraphQL field + and given value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`VirtualConnectionSortOrder`): Sort by given fields. + The sort orders defined first in the list will take priority. If + there are no given sort orders or a tie on the final sorted + field then the resulting set will be sorted by ID in ascending + order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + uri = sgqlc.types.Field(String, graphql_name="uri") + """Uri of the workbook""" + + views = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(View))), + graphql_name="views", + args=sgqlc.types.ArgDict( + ( + ( + "filter", + sgqlc.types.Arg(View_Filter, graphql_name="filter", default=None), + ), + ( + "order_by", + sgqlc.types.Arg( + ViewSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Views that are contained in this workbook + + Arguments: + + * `filter` (`View_Filter`): Filter by GraphQL field and given + value + * `order_by` (`ViewSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + views_connection = sgqlc.types.Field( + ViewsConnection, + graphql_name="viewsConnection", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ( + "filter", + sgqlc.types.Arg(View_Filter, graphql_name="filter", default=None), + ), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("offset", sgqlc.types.Arg(Int, graphql_name="offset", default=None)), + ( + "order_by", + sgqlc.types.Arg( + ViewSortOrder, graphql_name="orderBy", default=None + ), + ), + ( + "permission_mode", + sgqlc.types.Arg( + PermissionMode, + graphql_name="permissionMode", + default="OBFUSCATE_RESULTS", + ), + ), + ) + ), + ) + """Views that are contained in this workbook + + Arguments: + + * `after` (`String`): The cursor to receive the next page of + objects. If no cursor is supplied it will start at the beginning + of the list. Offset can not be set at the same time. This is the + preferred API to use if possible as it is faster. + * `filter` (`View_Filter`): Filter by GraphQL field and given + value + * `first` (`Int`): Maximum number of objects to be returned in a + page. The default is 100 + * `offset` (`Int`): The number of entries to offset the start of + the page by. If no offset is supplied it will start at the + beginning of the list. After can not be set at the same time. + * `order_by` (`ViewSortOrder`): Sort by given fields. The sort + orders defined first in the list will take priority. If there + are no given sort orders or a tie on the final sorted field then + the resulting set will be sorted by ID in ascending order. + * `permission_mode` (`PermissionMode`): Results filtering mode. + (default: `OBFUSCATE_RESULTS`) + """ + + vizportal_url_id = sgqlc.types.Field( + sgqlc.types.non_null(String), graphql_name="vizportalUrlId" + ) + """VizPortal URL ID; used for URL generation""" + + +######################################################################## +# Unions +######################################################################## + +######################################################################## +# Schema Entry Points +######################################################################## +tableau_schema.query_type = Query +tableau_schema.mutation_type = None +tableau_schema.subscription_type = None diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/__init__.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/__init__.py new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/schema.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/schema.py new file mode 100644 index 0000000000000..681f7d115f2c2 --- /dev/null +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/schema.py @@ -0,0 +1,1893 @@ +from datetime import datetime +from enum import Enum +from typing import Annotated, List, Literal, Optional, Union + +from pydantic import BaseModel, Field + + +class FieldDataType(str, Enum): + """Possible data types for a field.""" + + BOOLEAN = "BOOLEAN" + DATE = "DATE" + DATETIME = "DATETIME" + INTEGER = "INTEGER" + REAL = "REAL" + SPATIAL = "SPATIAL" + STRING = "STRING" + TABLE = "TABLE" + TUPLE = "TUPLE" + UNKNOWN = "UNKNOWN" + + +class FieldRole(str, Enum): + """Possible roles of a field.""" + + DIMENSION = "DIMENSION" + MEASURE = "MEASURE" + UNKNOWN = "UNKNOWN" + + +class FieldRoleCategory(str, Enum): + """Possible categories of a field role.""" + + NOMINAL = "NOMINAL" + ORDINAL = "ORDINAL" + QUANTITATIVE = "QUANTITATIVE" + UNKNOWN = "UNKNOWN" + + +class RemoteType(str, Enum): + """Possible types of remote types + + Types correspond to OLEDB types here: https://referencesource.microsoft.com/#system.data/System/Data/OleDb/OLEDB_Enum.cs,364" + + Types prefixed with 'WDC' correspond to Tableau's Web Data Connector types: + https://tableau.github.io/webdataconnector/docs/api_ref.html#webdataconnectorapi.datatypeenum + """ + + ARRAY = "ARRAY" + BOOL = "BOOL" + BSTR = "BSTR" + BYREF = "BYREF" + BYTES = "BYTES" + CY = "CY" + DATE = "DATE" + DBDATE = "DBDATE" + DBTIME = "DBTIME" + DBTIMESTAMP = "DBTIMESTAMP" + DECIMAL = "DECIMAL" + EMPTY = "EMPTY" + ERROR = "ERROR" + FILETIME = "FILETIME" + GUID = "GUID" + HCHAPTER = "HCHAPTER" + I1 = "I1" + I2 = "I2" + I4 = "I4" + I8 = "I8" + IDISPATCH = "IDISPATCH" + IUNKNOWN = "IUNKNOWN" + NULL = "NULL" + NUMERIC = "NUMERIC" + PROPVARIANT = "PROPVARIANT" + R4 = "R4" + R8 = "R8" + RESERVED = "RESERVED" + STR = "STR" + UDT = "UDT" + UI1 = "UI1" + UI2 = "UI2" + UI4 = "UI4" + UI8 = "UI8" + VARIANT = "VARIANT" + VARNUMERIC = "VARNUMERIC" + VECTOR = "VECTOR" + WDC_BOOL = "WDC_BOOL" + WDC_DATE = "WDC_DATE" + WDC_DATETIME = "WDC_DATETIME" + WDC_FLOAT = "WDC_FLOAT" + WDC_GEOMETRY = "WDC_GEOMETRY" + WDC_INT = "WDC_INT" + WDC_STRING = "WDC_STRING" + WSTR = "WSTR" + + +class GetItems_databaseTablesConnectionDatabasetablesconnectionNodesColumns(BaseModel): + """GraphQL type for a table column""" + + typename: Literal["Column"] = Field(alias="__typename", default="Column") + remote_type: RemoteType = Field(alias="remoteType") + "Remote type on the database. Types correspond to OLEDB types here: https://referencesource.microsoft.com/#system.data/System/Data/OleDb/OLEDB_Enum.cs,364" + name: Optional[str] = Field(default=None) + "Name of column" + + +class GetItems_databaseTablesConnectionDatabasetablesconnectionNodes(BaseModel): + """A table that is contained in a database""" + + typename: Literal["DatabaseTable"] = Field( + alias="__typename", default="DatabaseTable" + ) + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + is_embedded: Optional[bool] = Field(default=None, alias="isEmbedded") + "True if this table is embedded in Tableau content" + columns: List[GetItems_databaseTablesConnectionDatabasetablesconnectionNodesColumns] + "Columns contained in this table" + + +class GetItems_databaseTablesConnectionDatabasetablesconnectionPageinfo(BaseModel): + """Information about pagination in a connection""" + + typename: Literal["PageInfo"] = Field(alias="__typename", default="PageInfo") + has_next_page: bool = Field(alias="hasNextPage") + "Indicates if there are more objects to fetch" + end_cursor: Optional[str] = Field(default=None, alias="endCursor") + "Cursor to use in subsequent query to fetch next page of objects" + + +class GetItems_databaseTablesConnectionDatabasetablesconnection(BaseModel): + """Connection Type for DatabaseTable""" + + typename: Literal["DatabaseTablesConnection"] = Field( + alias="__typename", default="DatabaseTablesConnection" + ) + nodes: List[GetItems_databaseTablesConnectionDatabasetablesconnectionNodes] + "List of nodes" + page_info: GetItems_databaseTablesConnectionDatabasetablesconnectionPageinfo = ( + Field(alias="pageInfo") + ) + "Information for pagination" + + +class GetItems_databaseTablesConnection(BaseModel): + database_tables_connection: GetItems_databaseTablesConnectionDatabasetablesconnection = Field( + alias="databaseTablesConnection" + ) + "Fetch DatabaseTables with support for pagination" + + class Arguments(BaseModel): + first: Optional[int] = Field(default=None) + after: Optional[str] = Field(default=None) + + class Meta: + document = 'query GetItems_databaseTablesConnection($first: Int, $after: String) {\n databaseTablesConnection(\n first: $first\n after: $after\n filter: {idWithin: ["76e2151b-124f-7ec8-896b-dd107eafca05", "a1b165ad-c7c2-282d-94c5-1b8a877936ee", "2d3bdb4e-08da-a6da-fecb-a3c10abba357", "92b0a3ae-2fc9-1b42-47e0-c17d0f0b615a", "63ffbbfe-8c2d-c4f3-7a28-e11f247227c7", "06d776e1-9376-bc06-84d5-c7a5c4253bf5", "159ed86e-796f-3f13-8f07-3e63c271015e", "2f2ccb48-edd5-0e02-4d51-eb3b0819fbf1", "2fe499f7-9c5a-81ef-f32d-9553dcc86044", "4a34ada9-ed4a-089f-01d0-4a1f230ee2e6"]}\n ) {\n nodes {\n id\n isEmbedded\n columns {\n remoteType\n name\n __typename\n }\n __typename\n }\n pageInfo {\n hasNextPage\n endCursor\n __typename\n }\n __typename\n }\n}' + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBase( + BaseModel +): + """A database containing tables""" + + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + id: str + "Unique identifier used by the Metadata API. Not the same as the numeric ID used on server" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBaseCloudFile( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["CloudFile"] = Field(alias="__typename", default="CloudFile") + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBaseDataCloud( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["DataCloud"] = Field(alias="__typename", default="DataCloud") + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBaseDatabaseServer( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["DatabaseServer"] = Field( + alias="__typename", default="DatabaseServer" + ) + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBaseFile( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["File"] = Field(alias="__typename", default="File") + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBaseWebDataConnector( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["WebDataConnector"] = Field( + alias="__typename", default="WebDataConnector" + ) + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtables( + BaseModel +): + """A table that is contained in a database""" + + typename: Literal["DatabaseTable"] = Field( + alias="__typename", default="DatabaseTable" + ) + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + database: Optional[ + Annotated[ + Union[ + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBaseCloudFile, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBaseDataCloud, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBaseDatabaseServer, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBaseFile, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtablesDatabaseBaseWebDataConnector, + ], + Field(discriminator="typename"), + ] + ] = Field(default=None) + "The database to which this table belongs" + the_schema: Optional[str] = Field( + default=None, alias="schema" + ) # !! schema is a reserved word + "Name of table schema.\n \nNote: For some databases, such as Amazon Athena and Exasol, the schema attribute may not return the correct schema name for the table. For more information, see https://help.tableau.com/current/api/metadata_api/en-us/docs/meta_api_model.html#schema_attribute." + full_name: Optional[str] = Field(default=None, alias="fullName") + "Fully qualified table name" + connection_type: Optional[str] = Field(default=None, alias="connectionType") + "Connection type of parent database" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceBase( + BaseModel +): + """Root GraphQL type for embedded and published data sources + + Data sources are a way to represent how Tableau Desktop and Tableau Server model and connect to data. Data sources can be published separately, as a published data source, or may be contained in a workbook as an embedded data source. + + See https://onlinehelp.tableau.com/current/server/en-us/datasource.htm""" + + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + upstream_tables: List[ + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceUpstreamtables + ] = Field(alias="upstreamTables") + "Tables upstream from this data source" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceBaseEmbeddedDatasource( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceBase, + BaseModel, +): + typename: Literal["EmbeddedDatasource"] = Field( + alias="__typename", default="EmbeddedDatasource" + ) + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceBasePublishedDatasource( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceBase, + BaseModel, +): + typename: Literal["PublishedDatasource"] = Field( + alias="__typename", default="PublishedDatasource" + ) + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfields( + BaseModel +): + """ColumnFields are a type of field which directly connects to a column in some type of table.""" + + typename: Literal["ColumnField"] = Field(alias="__typename", default="ColumnField") + datasource: Optional[ + Annotated[ + Union[ + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceBaseEmbeddedDatasource, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfieldsDatasourceBasePublishedDatasource, + ], + Field(discriminator="typename"), + ] + ] = Field(default=None) + "Data source that contains this field" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumns( + BaseModel +): + """GraphQL type for a table column""" + + typename: Literal["Column"] = Field(alias="__typename", default="Column") + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name of column" + remote_type: RemoteType = Field(alias="remoteType") + "Remote type on the database. Types correspond to OLEDB types here: https://referencesource.microsoft.com/#system.data/System/Data/OleDb/OLEDB_Enum.cs,364" + description: Optional[str] = Field(default=None) + "User modifiable description of this column" + referenced_by_fields: Optional[ + List[ + Optional[ + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsReferencedbyfields + ] + ] + ] = Field(default=None, alias="referencedByFields") + "The column field that references this column" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBase( + BaseModel +): + """A database containing tables""" + + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + id: str + "Unique identifier used by the Metadata API. Not the same as the numeric ID used on server" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBaseCloudFile( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBase, + BaseModel, +): + typename: Literal["CloudFile"] = Field(alias="__typename", default="CloudFile") + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBaseDataCloud( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBase, + BaseModel, +): + typename: Literal["DataCloud"] = Field(alias="__typename", default="DataCloud") + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBaseDatabaseServer( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBase, + BaseModel, +): + typename: Literal["DatabaseServer"] = Field( + alias="__typename", default="DatabaseServer" + ) + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBaseFile( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBase, + BaseModel, +): + typename: Literal["File"] = Field(alias="__typename", default="File") + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBaseWebDataConnector( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBase, + BaseModel, +): + typename: Literal["WebDataConnector"] = Field( + alias="__typename", default="WebDataConnector" + ) + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesColumnsconnection( + BaseModel +): + """Connection Type for Column""" + + typename: Literal["ColumnsConnection"] = Field( + alias="__typename", default="ColumnsConnection" + ) + total_count: int = Field(alias="totalCount") + "Total number of objects in connection" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTables(BaseModel): + """A table that is contained in a database""" + + typename: Literal["DatabaseTable"] = Field( + alias="__typename", default="DatabaseTable" + ) + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + database: Optional[ + Annotated[ + Union[ + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBaseCloudFile, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBaseDataCloud, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBaseDatabaseServer, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBaseFile, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesDatabaseBaseWebDataConnector, + ], + Field(discriminator="typename"), + ] + ] = Field(default=None) + "The database to which this table belongs" + the_schema: Optional[str] = Field( + default=None, alias="schema" + ) # !! schema is a reserved word + "Name of table schema.\n \nNote: For some databases, such as Amazon Athena and Exasol, the schema attribute may not return the correct schema name for the table. For more information, see https://help.tableau.com/current/api/metadata_api/en-us/docs/meta_api_model.html#schema_attribute." + full_name: Optional[str] = Field(default=None, alias="fullName") + "Fully qualified table name" + connection_type: Optional[str] = Field(default=None, alias="connectionType") + "Connection type of parent database" + description: Optional[str] = Field(default=None) + "User modifiable description of this table" + columns_connection: Optional[ + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTablesColumnsconnection + ] = Field(default=None, alias="columnsConnection") + "Columns contained in this table" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBase( + BaseModel +): + """A database containing tables""" + + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + id: str + "Unique identifier used by the Metadata API. Not the same as the numeric ID used on server" + connection_type: Optional[str] = Field(default=None, alias="connectionType") + "Connection type shortname" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBaseCloudFile( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBase, + BaseModel, +): + typename: Literal["CloudFile"] = Field(alias="__typename", default="CloudFile") + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBaseDataCloud( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBase, + BaseModel, +): + typename: Literal["DataCloud"] = Field(alias="__typename", default="DataCloud") + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBaseDatabaseServer( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBase, + BaseModel, +): + typename: Literal["DatabaseServer"] = Field( + alias="__typename", default="DatabaseServer" + ) + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBaseFile( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBase, + BaseModel, +): + typename: Literal["File"] = Field(alias="__typename", default="File") + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBaseWebDataConnector( + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBase, + BaseModel, +): + typename: Literal["WebDataConnector"] = Field( + alias="__typename", default="WebDataConnector" + ) + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodes(BaseModel): + """A table that represents the result of evaluating a custom SQL query. These "tables" are owned by the Tableau data source (embedded or published) which contains the SQL query, so they only exist within that data source.""" + + typename: Literal["CustomSQLTable"] = Field( + alias="__typename", default="CustomSQLTable" + ) + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + query: Optional[str] = Field(default=None) + "Text of the query" + columns: List[ + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumns + ] + "Columns contained in this table" + tables: List[GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTables] + "Actual tables that this query references." + connection_type: Optional[str] = Field(default=None, alias="connectionType") + "Connection type shortname" + database: Optional[ + Annotated[ + Union[ + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBaseCloudFile, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBaseDataCloud, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBaseDatabaseServer, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBaseFile, + GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesDatabaseBaseWebDataConnector, + ], + Field(discriminator="typename"), + ] + ] = Field(default=None) + "Database this query is executed on" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnectionPageinfo(BaseModel): + """Information about pagination in a connection""" + + typename: Literal["PageInfo"] = Field(alias="__typename", default="PageInfo") + has_next_page: bool = Field(alias="hasNextPage") + "Indicates if there are more objects to fetch" + end_cursor: Optional[str] = Field(default=None, alias="endCursor") + "Cursor to use in subsequent query to fetch next page of objects" + + +class GetItems_customSQLTablesConnectionCustomsqltablesconnection(BaseModel): + """Connection Type for CustomSQLTable""" + + typename: Literal["CustomSQLTablesConnection"] = Field( + alias="__typename", default="CustomSQLTablesConnection" + ) + nodes: List[GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodes] + "List of nodes" + page_info: GetItems_customSQLTablesConnectionCustomsqltablesconnectionPageinfo = ( + Field(alias="pageInfo") + ) + "Information for pagination" + + +class GetItems_customSQLTablesConnection(BaseModel): + custom_sql_tables_connection: GetItems_customSQLTablesConnectionCustomsqltablesconnection = Field( + alias="customSQLTablesConnection" + ) + "Fetch CustomSQLTables with support for pagination" + + class Arguments(BaseModel): + first: Optional[int] = Field(default=None) + after: Optional[str] = Field(default=None) + + class Meta: + document = 'query GetItems_customSQLTablesConnection($first: Int, $after: String) {\n customSQLTablesConnection(\n first: $first\n after: $after\n filter: {idWithin: ["81335c49-5edc-bbfa-77c9-c4a1cd444501", "48c19c5f-4300-07bb-17ee-1fbdf6824ff6"]}\n ) {\n nodes {\n id\n name\n query\n columns {\n id\n name\n remoteType\n description\n referencedByFields {\n datasource {\n __typename\n id\n name\n upstreamTables {\n id\n name\n database {\n name\n id\n __typename\n }\n schema\n fullName\n connectionType\n __typename\n }\n ... on PublishedDatasource {\n projectName\n luid\n }\n ... on EmbeddedDatasource {\n workbook {\n id\n name\n projectName\n luid\n }\n }\n }\n __typename\n }\n __typename\n }\n tables {\n id\n name\n database {\n name\n id\n __typename\n }\n schema\n fullName\n connectionType\n description\n columnsConnection {\n totalCount\n __typename\n }\n __typename\n }\n connectionType\n database {\n name\n id\n connectionType\n __typename\n }\n __typename\n }\n pageInfo {\n hasNextPage\n endCursor\n __typename\n }\n __typename\n }\n}' + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBase( + BaseModel +): + """A database containing tables""" + + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + id: str + "Unique identifier used by the Metadata API. Not the same as the numeric ID used on server" + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBaseCloudFile( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["CloudFile"] = Field(alias="__typename", default="CloudFile") + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBaseDataCloud( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["DataCloud"] = Field(alias="__typename", default="DataCloud") + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBaseDatabaseServer( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["DatabaseServer"] = Field( + alias="__typename", default="DatabaseServer" + ) + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBaseFile( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["File"] = Field(alias="__typename", default="File") + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBaseWebDataConnector( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["WebDataConnector"] = Field( + alias="__typename", default="WebDataConnector" + ) + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesColumnsconnection( + BaseModel +): + """Connection Type for Column""" + + typename: Literal["ColumnsConnection"] = Field( + alias="__typename", default="ColumnsConnection" + ) + total_count: int = Field(alias="totalCount") + "Total number of objects in connection" + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtables( + BaseModel +): + """A table that is contained in a database""" + + typename: Literal["DatabaseTable"] = Field( + alias="__typename", default="DatabaseTable" + ) + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + database: Optional[ + Annotated[ + Union[ + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBaseCloudFile, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBaseDataCloud, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBaseDatabaseServer, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBaseFile, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesDatabaseBaseWebDataConnector, + ], + Field(discriminator="typename"), + ] + ] = Field(default=None) + "The database to which this table belongs" + the_schema: Optional[str] = Field( + default=None, alias="schema" + ) # !! schema is a reserved word + "Name of table schema.\n \nNote: For some databases, such as Amazon Athena and Exasol, the schema attribute may not return the correct schema name for the table. For more information, see https://help.tableau.com/current/api/metadata_api/en-us/docs/meta_api_model.html#schema_attribute." + full_name: Optional[str] = Field(default=None, alias="fullName") + "Fully qualified table name" + connection_type: Optional[str] = Field(default=None, alias="connectionType") + "Connection type of parent database" + description: Optional[str] = Field(default=None) + "User modifiable description of this table" + columns_connection: Optional[ + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtablesColumnsconnection + ] = Field(default=None, alias="columnsConnection") + "Columns contained in this table" + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBase( + BaseModel +): + """Base GraphQL type for a field""" + + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server" + description: Optional[str] = Field(default=None) + "Description of field shown in server and desktop clients" + is_hidden: Optional[bool] = Field(default=None, alias="isHidden") + "True if the field is hidden" + folder_name: Optional[str] = Field(default=None, alias="folderName") + "Name of folder if the field is in a folder. See https://onlinehelp.tableau.com/current/pro/desktop/en-us/datafields_dwfeatures.html#Organize" + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseBinField( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["BinField"] = Field(alias="__typename", default="BinField") + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseCalculatedField( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["CalculatedField"] = Field( + alias="__typename", default="CalculatedField" + ) + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseColumnField( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["ColumnField"] = Field(alias="__typename", default="ColumnField") + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseCombinedField( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["CombinedField"] = Field( + alias="__typename", default="CombinedField" + ) + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseCombinedSetField( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["CombinedSetField"] = Field( + alias="__typename", default="CombinedSetField" + ) + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseDatasourceField( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["DatasourceField"] = Field( + alias="__typename", default="DatasourceField" + ) + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseGroupField( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["GroupField"] = Field(alias="__typename", default="GroupField") + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseHierarchyField( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["HierarchyField"] = Field( + alias="__typename", default="HierarchyField" + ) + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseSetField( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["SetField"] = Field(alias="__typename", default="SetField") + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesOwner( + BaseModel +): + """User on a site on Tableau server""" + + typename: Literal["TableauUser"] = Field(alias="__typename", default="TableauUser") + username: Optional[str] = Field(default=None) + "Username of this user" + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesTags( + BaseModel +): + """A tag associated with content items""" + + typename: Literal["Tag"] = Field(alias="__typename", default="Tag") + name: Optional[str] = Field(default=None) + "The name of the tag" + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodes( + BaseModel +): + """A Tableau data source that has been published separately to Tableau Server. It can be used by multiple workbooks.""" + + typename: Literal["PublishedDatasource"] = Field( + alias="__typename", default="PublishedDatasource" + ) + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + luid: str + "Locally unique identifier used for the REST API on the Tableau Server" + has_extracts: Optional[bool] = Field(default=None, alias="hasExtracts") + "True if datasource contains extracted data" + extract_last_refresh_time: Optional[datetime] = Field( + default=None, alias="extractLastRefreshTime" + ) + "Time an extract was last fully refreshed" + extract_last_incremental_update_time: Optional[datetime] = Field( + default=None, alias="extractLastIncrementalUpdateTime" + ) + "Time an extract was last incrementally updated" + extract_last_update_time: Optional[datetime] = Field( + default=None, alias="extractLastUpdateTime" + ) + "Time an extract was last updated by either a full refresh, incremental update, or creation" + upstream_tables: List[ + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesUpstreamtables + ] = Field(alias="upstreamTables") + "Tables upstream from this data source" + fields: List[ + Annotated[ + Union[ + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseBinField, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseCalculatedField, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseColumnField, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseCombinedField, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseCombinedSetField, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseDatasourceField, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseGroupField, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseHierarchyField, + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesFieldsBaseSetField, + ], + Field(discriminator="typename"), + ] + ] + "Fields usable in workbooks connected to this data source" + owner: ( + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesOwner + ) + "User who owns this data source" + description: Optional[str] = Field(default=None) + "Description of the datasource" + uri: Optional[str] = Field(default=None) + "Uri of the datasource" + project_name: Optional[str] = Field(default=None, alias="projectName") + "The name of the project that contains this published data source." + tags: List[ + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodesTags + ] + "Tags associated with the published datasource" + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionPageinfo( + BaseModel +): + """Information about pagination in a connection""" + + typename: Literal["PageInfo"] = Field(alias="__typename", default="PageInfo") + has_next_page: bool = Field(alias="hasNextPage") + "Indicates if there are more objects to fetch" + end_cursor: Optional[str] = Field(default=None, alias="endCursor") + "Cursor to use in subsequent query to fetch next page of objects" + + +class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnection(BaseModel): + """Connection Type for PublishedDatasource""" + + typename: Literal["PublishedDatasourcesConnection"] = Field( + alias="__typename", default="PublishedDatasourcesConnection" + ) + nodes: List[ + GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodes + ] + "List of nodes" + page_info: GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionPageinfo = Field( + alias="pageInfo" + ) + "Information for pagination" + + +class GetItems_publishedDatasourcesConnection(BaseModel): + published_datasources_connection: GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnection = Field( + alias="publishedDatasourcesConnection" + ) + "Fetch PublishedDatasources with support for pagination" + + class Arguments(BaseModel): + first: Optional[int] = Field(default=None) + after: Optional[str] = Field(default=None) + + class Meta: + document = 'query GetItems_publishedDatasourcesConnection($first: Int, $after: String) {\n publishedDatasourcesConnection(\n first: $first\n after: $after\n filter: {idWithin: ["35d62018-68e1-6ad4-2cf0-d3ede4ee9a67", "87d9d9d8-59a8-adc3-3e06-f75c5b98ec52", "ae8b52c9-1481-06fd-fe96-e6d4938f9fcb"]}\n ) {\n nodes {\n __typename\n id\n name\n luid\n hasExtracts\n extractLastRefreshTime\n extractLastIncrementalUpdateTime\n extractLastUpdateTime\n upstreamTables {\n id\n name\n database {\n name\n id\n __typename\n }\n schema\n fullName\n connectionType\n description\n columnsConnection {\n totalCount\n __typename\n }\n __typename\n }\n fields {\n __typename\n id\n name\n description\n isHidden\n folderName\n ... on ColumnField {\n dataCategory\n role\n dataType\n defaultFormat\n aggregation\n }\n ... on CalculatedField {\n role\n dataType\n defaultFormat\n aggregation\n formula\n }\n ... on GroupField {\n role\n dataType\n }\n }\n owner {\n username\n __typename\n }\n description\n uri\n projectName\n tags {\n name\n __typename\n }\n }\n pageInfo {\n hasNextPage\n endCursor\n __typename\n }\n __typename\n }\n}' + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsDatasourceBase( + BaseModel +): + """Root GraphQL type for embedded and published data sources + + Data sources are a way to represent how Tableau Desktop and Tableau Server model and connect to data. Data sources can be published separately, as a published data source, or may be contained in a workbook as an embedded data source. + + See https://onlinehelp.tableau.com/current/server/en-us/datasource.htm""" + + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsDatasourceBaseEmbeddedDatasource( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsDatasourceBase, + BaseModel, +): + typename: Literal["EmbeddedDatasource"] = Field( + alias="__typename", default="EmbeddedDatasource" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsDatasourceBasePublishedDatasource( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsDatasourceBase, + BaseModel, +): + typename: Literal["PublishedDatasource"] = Field( + alias="__typename", default="PublishedDatasource" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBase(BaseModel): + """Base GraphQL type for a field""" + + name: Optional[str] = Field(default=None) + "Name shown in server" + datasource: Optional[ + Annotated[ + Union[ + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsDatasourceBaseEmbeddedDatasource, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsDatasourceBasePublishedDatasource, + ], + Field(discriminator="typename"), + ] + ] = Field(default=None) + "Data source that contains this field" + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseBinField( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBase, BaseModel +): + typename: Literal["BinField"] = Field(alias="__typename", default="BinField") + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseCalculatedField( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBase, BaseModel +): + typename: Literal["CalculatedField"] = Field( + alias="__typename", default="CalculatedField" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseColumnField( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBase, BaseModel +): + typename: Literal["ColumnField"] = Field(alias="__typename", default="ColumnField") + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseCombinedField( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBase, BaseModel +): + typename: Literal["CombinedField"] = Field( + alias="__typename", default="CombinedField" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseCombinedSetField( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBase, BaseModel +): + typename: Literal["CombinedSetField"] = Field( + alias="__typename", default="CombinedSetField" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseDatasourceField( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBase, BaseModel +): + typename: Literal["DatasourceField"] = Field( + alias="__typename", default="DatasourceField" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseGroupField( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBase, BaseModel +): + typename: Literal["GroupField"] = Field(alias="__typename", default="GroupField") + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseHierarchyField( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBase, BaseModel +): + typename: Literal["HierarchyField"] = Field( + alias="__typename", default="HierarchyField" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseSetField( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBase, BaseModel +): + typename: Literal["SetField"] = Field(alias="__typename", default="SetField") + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumnsTableBase(BaseModel): + """A table containing columns""" + + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumnsTableBaseCustomSQLTable( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumnsTableBase, BaseModel +): + typename: Literal["CustomSQLTable"] = Field( + alias="__typename", default="CustomSQLTable" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumnsTableBaseDatabaseTable( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumnsTableBase, BaseModel +): + typename: Literal["DatabaseTable"] = Field( + alias="__typename", default="DatabaseTable" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumnsTableBaseVirtualConnectionTable( + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumnsTableBase, BaseModel +): + typename: Literal["VirtualConnectionTable"] = Field( + alias="__typename", default="VirtualConnectionTable" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumns(BaseModel): + """GraphQL type for a table column""" + + typename: Literal["Column"] = Field(alias="__typename", default="Column") + name: Optional[str] = Field(default=None) + "Name of column" + table: Optional[ + Annotated[ + Union[ + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumnsTableBaseCustomSQLTable, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumnsTableBaseDatabaseTable, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumnsTableBaseVirtualConnectionTable, + ], + Field(discriminator="typename"), + ] + ] = Field(default=None) + "The table that this column belongs to" + + +class GetItems_fieldsConnectionFieldsconnectionNodesBase(BaseModel): + """Base GraphQL type for a field""" + + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + upstream_fields: List[ + Optional[ + Annotated[ + Union[ + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseBinField, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseCalculatedField, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseColumnField, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseCombinedField, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseCombinedSetField, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseDatasourceField, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseGroupField, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseHierarchyField, + GetItems_fieldsConnectionFieldsconnectionNodesUpstreamfieldsBaseSetField, + ], + Field(discriminator="typename"), + ] + ] + ] = Field(alias="upstreamFields") + "fields that are upstream of this field" + upstream_columns: List[ + Optional[GetItems_fieldsConnectionFieldsconnectionNodesUpstreamcolumns] + ] = Field(alias="upstreamColumns") + "All upstream columns this field references" + + +class GetItems_fieldsConnectionFieldsconnectionNodesBaseBinField( + GetItems_fieldsConnectionFieldsconnectionNodesBase, BaseModel +): + typename: Literal["BinField"] = Field(alias="__typename", default="BinField") + + +class GetItems_fieldsConnectionFieldsconnectionNodesBaseCalculatedField( + GetItems_fieldsConnectionFieldsconnectionNodesBase, BaseModel +): + typename: Literal["CalculatedField"] = Field( + alias="__typename", default="CalculatedField" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesBaseColumnField( + GetItems_fieldsConnectionFieldsconnectionNodesBase, BaseModel +): + typename: Literal["ColumnField"] = Field(alias="__typename", default="ColumnField") + + +class GetItems_fieldsConnectionFieldsconnectionNodesBaseCombinedField( + GetItems_fieldsConnectionFieldsconnectionNodesBase, BaseModel +): + typename: Literal["CombinedField"] = Field( + alias="__typename", default="CombinedField" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesBaseCombinedSetField( + GetItems_fieldsConnectionFieldsconnectionNodesBase, BaseModel +): + typename: Literal["CombinedSetField"] = Field( + alias="__typename", default="CombinedSetField" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesBaseDatasourceField( + GetItems_fieldsConnectionFieldsconnectionNodesBase, BaseModel +): + typename: Literal["DatasourceField"] = Field( + alias="__typename", default="DatasourceField" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesBaseGroupField( + GetItems_fieldsConnectionFieldsconnectionNodesBase, BaseModel +): + typename: Literal["GroupField"] = Field(alias="__typename", default="GroupField") + + +class GetItems_fieldsConnectionFieldsconnectionNodesBaseHierarchyField( + GetItems_fieldsConnectionFieldsconnectionNodesBase, BaseModel +): + typename: Literal["HierarchyField"] = Field( + alias="__typename", default="HierarchyField" + ) + + +class GetItems_fieldsConnectionFieldsconnectionNodesBaseSetField( + GetItems_fieldsConnectionFieldsconnectionNodesBase, BaseModel +): + typename: Literal["SetField"] = Field(alias="__typename", default="SetField") + + +class GetItems_fieldsConnectionFieldsconnectionPageinfo(BaseModel): + """Information about pagination in a connection""" + + typename: Literal["PageInfo"] = Field(alias="__typename", default="PageInfo") + has_next_page: bool = Field(alias="hasNextPage") + "Indicates if there are more objects to fetch" + end_cursor: Optional[str] = Field(default=None, alias="endCursor") + "Cursor to use in subsequent query to fetch next page of objects" + + +class GetItems_fieldsConnectionFieldsconnection(BaseModel): + """Connection Type for Field""" + + typename: Literal["FieldsConnection"] = Field( + alias="__typename", default="FieldsConnection" + ) + nodes: List[ + Annotated[ + Union[ + GetItems_fieldsConnectionFieldsconnectionNodesBaseBinField, + GetItems_fieldsConnectionFieldsconnectionNodesBaseCalculatedField, + GetItems_fieldsConnectionFieldsconnectionNodesBaseColumnField, + GetItems_fieldsConnectionFieldsconnectionNodesBaseCombinedField, + GetItems_fieldsConnectionFieldsconnectionNodesBaseCombinedSetField, + GetItems_fieldsConnectionFieldsconnectionNodesBaseDatasourceField, + GetItems_fieldsConnectionFieldsconnectionNodesBaseGroupField, + GetItems_fieldsConnectionFieldsconnectionNodesBaseHierarchyField, + GetItems_fieldsConnectionFieldsconnectionNodesBaseSetField, + ], + Field(discriminator="typename"), + ] + ] + "List of nodes" + page_info: GetItems_fieldsConnectionFieldsconnectionPageinfo = Field( + alias="pageInfo" + ) + "Information for pagination" + + +class GetItems_fieldsConnection(BaseModel): + fields_connection: GetItems_fieldsConnectionFieldsconnection = Field( + alias="fieldsConnection" + ) + "Fetch Fields with support for pagination" + + class Arguments(BaseModel): + first: Optional[int] = Field(default=None) + after: Optional[str] = Field(default=None) + + class Meta: + document = 'query GetItems_fieldsConnection($first: Int, $after: String) {\n fieldsConnection(\n first: $first\n after: $after\n filter: {idWithin: ["668470bc-f0c9-ec5d-7a4b-172370d6ef45", "66bd48ba-a895-4951-a4e1-d26fc191eae9", "672a63ee-c34b-8cb4-506b-163fcb131a52", "72684adf-d214-0a9a-946c-dd7b3879b51f", "76636a30-dfbf-0107-0190-a0fc6ce201be", "77aa21d6-3b79-0be0-d309-3d36ef1efe71", "8fbf178a-ceef-2c97-3ac8-26f95a004d67", "968608d1-5da4-1a97-e96a-269010d4ef5b", "b5ae252a-c3c0-3a2d-c147-7a39a8de59ef", "bc1641b9-525d-00c5-f163-02519d46f0fd"]}\n ) {\n nodes {\n id\n upstreamFields {\n name\n datasource {\n id\n __typename\n }\n __typename\n }\n upstreamColumns {\n name\n table {\n __typename\n id\n }\n __typename\n }\n __typename\n }\n pageInfo {\n hasNextPage\n endCursor\n __typename\n }\n __typename\n }\n}' + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesDownstreamsheets( + BaseModel +): + """A sheet contained in a published workbook.""" + + typename: Literal["Sheet"] = Field(alias="__typename", default="Sheet") + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBase( + BaseModel +): + """A database containing tables""" + + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + id: str + "Unique identifier used by the Metadata API. Not the same as the numeric ID used on server" + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBaseCloudFile( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["CloudFile"] = Field(alias="__typename", default="CloudFile") + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBaseDataCloud( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["DataCloud"] = Field(alias="__typename", default="DataCloud") + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBaseDatabaseServer( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["DatabaseServer"] = Field( + alias="__typename", default="DatabaseServer" + ) + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBaseFile( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["File"] = Field(alias="__typename", default="File") + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBaseWebDataConnector( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBase, + BaseModel, +): + typename: Literal["WebDataConnector"] = Field( + alias="__typename", default="WebDataConnector" + ) + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesColumnsconnection( + BaseModel +): + """Connection Type for Column""" + + typename: Literal["ColumnsConnection"] = Field( + alias="__typename", default="ColumnsConnection" + ) + total_count: int = Field(alias="totalCount") + "Total number of objects in connection" + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtables( + BaseModel +): + """A table that is contained in a database""" + + typename: Literal["DatabaseTable"] = Field( + alias="__typename", default="DatabaseTable" + ) + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + database: Optional[ + Annotated[ + Union[ + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBaseCloudFile, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBaseDataCloud, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBaseDatabaseServer, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBaseFile, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesDatabaseBaseWebDataConnector, + ], + Field(discriminator="typename"), + ] + ] = Field(default=None) + "The database to which this table belongs" + the_schema: Optional[str] = Field( + default=None, alias="schema" + ) # !! schema is a reserved keyword + "Name of table schema.\n \nNote: For some databases, such as Amazon Athena and Exasol, the schema attribute may not return the correct schema name for the table. For more information, see https://help.tableau.com/current/api/metadata_api/en-us/docs/meta_api_model.html#schema_attribute." + full_name: Optional[str] = Field(default=None, alias="fullName") + "Fully qualified table name" + connection_type: Optional[str] = Field(default=None, alias="connectionType") + "Connection type of parent database" + description: Optional[str] = Field(default=None) + "User modifiable description of this table" + columns_connection: Optional[ + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtablesColumnsconnection + ] = Field(default=None, alias="columnsConnection") + "Columns contained in this table" + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBase( + BaseModel +): + """Base GraphQL type for a field""" + + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server" + description: Optional[str] = Field(default=None) + "Description of field shown in server and desktop clients" + is_hidden: Optional[bool] = Field(default=None, alias="isHidden") + "True if the field is hidden" + folder_name: Optional[str] = Field(default=None, alias="folderName") + "Name of folder if the field is in a folder. See https://onlinehelp.tableau.com/current/pro/desktop/en-us/datafields_dwfeatures.html#Organize" + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseBinField( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["BinField"] = Field(alias="__typename", default="BinField") + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseCalculatedField( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["CalculatedField"] = Field( + alias="__typename", default="CalculatedField" + ) + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseColumnField( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["ColumnField"] = Field(alias="__typename", default="ColumnField") + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseCombinedField( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["CombinedField"] = Field( + alias="__typename", default="CombinedField" + ) + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseCombinedSetField( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["CombinedSetField"] = Field( + alias="__typename", default="CombinedSetField" + ) + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseDatasourceField( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["DatasourceField"] = Field( + alias="__typename", default="DatasourceField" + ) + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseGroupField( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["GroupField"] = Field(alias="__typename", default="GroupField") + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseHierarchyField( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["HierarchyField"] = Field( + alias="__typename", default="HierarchyField" + ) + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseSetField( + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBase, + BaseModel, +): + typename: Literal["SetField"] = Field(alias="__typename", default="SetField") + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamdatasources( + BaseModel +): + """A Tableau data source that has been published separately to Tableau Server. It can be used by multiple workbooks.""" + + typename: Literal["PublishedDatasource"] = Field( + alias="__typename", default="PublishedDatasource" + ) + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesWorkbookOwner( + BaseModel +): + """User on a site on Tableau server""" + + typename: Literal["TableauUser"] = Field(alias="__typename", default="TableauUser") + username: Optional[str] = Field(default=None) + "Username of this user" + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesWorkbook( + BaseModel +): + """Workbooks are used to package up Tableau visualizations (which are called "sheets" in the Metadata API) and data models (which are called "embedded data sources" when they are owned by a workbook).""" + + typename: Literal["Workbook"] = Field(alias="__typename", default="Workbook") + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + project_name: Optional[str] = Field(default=None, alias="projectName") + "The name of the project in which the workbook is visible and usable." + luid: str + "Locally unique identifier used for the REST API on the Tableau Server" + owner: GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesWorkbookOwner + "User who owns this workbook" + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodes( + BaseModel +): + """A data source embedded in a workbook""" + + typename: Literal["EmbeddedDatasource"] = Field( + alias="__typename", default="EmbeddedDatasource" + ) + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + has_extracts: Optional[bool] = Field(default=None, alias="hasExtracts") + "True if datasource contains extracted data" + extract_last_refresh_time: Optional[datetime] = Field( + default=None, alias="extractLastRefreshTime" + ) + "Time an extract was last fully refreshed" + extract_last_incremental_update_time: Optional[datetime] = Field( + default=None, alias="extractLastIncrementalUpdateTime" + ) + "Time an extract was last incrementally updated" + extract_last_update_time: Optional[datetime] = Field( + default=None, alias="extractLastUpdateTime" + ) + "Time an extract was last updated by either a full refresh, incremental update, or creation" + downstream_sheets: List[ + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesDownstreamsheets + ] = Field(alias="downstreamSheets") + "Sheets downstream from this data source" + upstream_tables: List[ + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamtables + ] = Field(alias="upstreamTables") + "Tables upstream from this data source" + fields: List[ + Annotated[ + Union[ + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseBinField, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseCalculatedField, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseColumnField, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseCombinedField, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseCombinedSetField, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseDatasourceField, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseGroupField, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseHierarchyField, + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesFieldsBaseSetField, + ], + Field(discriminator="typename"), + ] + ] + "Fields, usually measures or dimensions, contained in the data source" + upstream_datasources: List[ + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUpstreamdatasources + ] = Field(alias="upstreamDatasources") + "Datasources upstream from this data source" + workbook: Optional[ + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesWorkbook + ] = Field(default=None) + "Workbook that contains these embedded datasources" + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionPageinfo( + BaseModel +): + """Information about pagination in a connection""" + + typename: Literal["PageInfo"] = Field(alias="__typename", default="PageInfo") + has_next_page: bool = Field(alias="hasNextPage") + "Indicates if there are more objects to fetch" + end_cursor: Optional[str] = Field(default=None, alias="endCursor") + "Cursor to use in subsequent query to fetch next page of objects" + + +class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnection(BaseModel): + """Connection Type for EmbeddedDatasource""" + + typename: Literal["EmbeddedDatasourcesConnection"] = Field( + alias="__typename", default="EmbeddedDatasourcesConnection" + ) + nodes: List[ + GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodes + ] + "List of nodes" + page_info: GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionPageinfo = Field( + alias="pageInfo" + ) + "Information for pagination" + + +class GetItems_embeddedDatasourcesConnection(BaseModel): + embedded_datasources_connection: GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnection = Field( + alias="embeddedDatasourcesConnection" + ) + "Fetch EmbeddedDatasources with support for pagination" + + class Arguments(BaseModel): + first: Optional[int] = Field(default=None) + after: Optional[str] = Field(default=None) + + class Meta: + document = 'query GetItems_embeddedDatasourcesConnection($first: Int, $after: String) {\n embeddedDatasourcesConnection(\n first: $first\n after: $after\n filter: {idWithin: ["7437c561-4e94-0283-3462-c6205c2288cd", "797a69b1-c32a-2fd4-62aa-99989c1858a6", "79871b17-d526-17be-df59-e001f7140924", "8f5e3006-6756-8eea-4fd3-44781cea1493", "1c5653d6-c448-0850-108b-5c78aeaf6b51", "6731f648-b756-31ea-fcdd-77309dd3b0c3", "6bd53e72-9fe4-ea86-3d23-14b826c13fa5", "3f46592d-f789-8f48-466e-69606990d589", "415ddd3e-be04-b466-bc7c-5678a4b0a733", "e9b47a00-12ff-72cc-9dfb-d34e0c65095d"]}\n ) {\n nodes {\n __typename\n id\n name\n hasExtracts\n extractLastRefreshTime\n extractLastIncrementalUpdateTime\n extractLastUpdateTime\n downstreamSheets {\n name\n id\n __typename\n }\n upstreamTables {\n id\n name\n database {\n name\n id\n __typename\n }\n schema\n fullName\n connectionType\n description\n columnsConnection {\n totalCount\n __typename\n }\n __typename\n }\n fields {\n __typename\n id\n name\n description\n isHidden\n folderName\n ... on ColumnField {\n dataCategory\n role\n dataType\n defaultFormat\n aggregation\n }\n ... on CalculatedField {\n role\n dataType\n defaultFormat\n aggregation\n formula\n }\n ... on GroupField {\n role\n dataType\n }\n }\n upstreamDatasources {\n id\n name\n __typename\n }\n workbook {\n id\n name\n projectName\n luid\n owner {\n username\n __typename\n }\n __typename\n }\n }\n pageInfo {\n hasNextPage\n endCursor\n __typename\n }\n __typename\n }\n}' + + +class GetItems_sheetsConnectionSheetsconnectionNodesTags(BaseModel): + """A tag associated with content items""" + + typename: Literal["Tag"] = Field(alias="__typename", default="Tag") + name: Optional[str] = Field(default=None) + "The name of the tag" + + +class GetItems_sheetsConnectionSheetsconnectionNodesContainedindashboards(BaseModel): + """A dashboard contained in a published workbook.""" + + typename: Literal["Dashboard"] = Field(alias="__typename", default="Dashboard") + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + path: Optional[str] = Field(default=None) + "Server path to dashboard" + + +class GetItems_sheetsConnectionSheetsconnectionNodesWorkbookOwner(BaseModel): + """User on a site on Tableau server""" + + typename: Literal["TableauUser"] = Field(alias="__typename", default="TableauUser") + username: Optional[str] = Field(default=None) + "Username of this user" + + +class GetItems_sheetsConnectionSheetsconnectionNodesWorkbook(BaseModel): + """Workbooks are used to package up Tableau visualizations (which are called "sheets" in the Metadata API) and data models (which are called "embedded data sources" when they are owned by a workbook).""" + + typename: Literal["Workbook"] = Field(alias="__typename", default="Workbook") + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + project_name: Optional[str] = Field(default=None, alias="projectName") + "The name of the project in which the workbook is visible and usable." + luid: str + "Locally unique identifier used for the REST API on the Tableau Server" + owner: GetItems_sheetsConnectionSheetsconnectionNodesWorkbookOwner + "User who owns this workbook" + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsDatasourceBase( + BaseModel +): + """Root GraphQL type for embedded and published data sources + + Data sources are a way to represent how Tableau Desktop and Tableau Server model and connect to data. Data sources can be published separately, as a published data source, or may be contained in a workbook as an embedded data source. + + See https://onlinehelp.tableau.com/current/server/en-us/datasource.htm""" + + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsDatasourceBaseEmbeddedDatasource( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsDatasourceBase, + BaseModel, +): + typename: Literal["EmbeddedDatasource"] = Field( + alias="__typename", default="EmbeddedDatasource" + ) + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsDatasourceBasePublishedDatasource( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsDatasourceBase, + BaseModel, +): + typename: Literal["PublishedDatasource"] = Field( + alias="__typename", default="PublishedDatasource" + ) + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBase(BaseModel): + """Base GraphQL type for a field""" + + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server" + description: Optional[str] = Field(default=None) + "Description of field shown in server and desktop clients" + datasource: Optional[ + Annotated[ + Union[ + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsDatasourceBaseEmbeddedDatasource, + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsDatasourceBasePublishedDatasource, + ], + Field(discriminator="typename"), + ] + ] = Field(default=None) + "Data source that contains this field" + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseBinField( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBase, BaseModel +): + typename: Literal["BinField"] = Field(alias="__typename", default="BinField") + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseCalculatedField( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBase, BaseModel +): + typename: Literal["CalculatedField"] = Field( + alias="__typename", default="CalculatedField" + ) + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseColumnField( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBase, BaseModel +): + typename: Literal["ColumnField"] = Field(alias="__typename", default="ColumnField") + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseCombinedField( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBase, BaseModel +): + typename: Literal["CombinedField"] = Field( + alias="__typename", default="CombinedField" + ) + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseCombinedSetField( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBase, BaseModel +): + typename: Literal["CombinedSetField"] = Field( + alias="__typename", default="CombinedSetField" + ) + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseDatasourceField( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBase, BaseModel +): + typename: Literal["DatasourceField"] = Field( + alias="__typename", default="DatasourceField" + ) + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseGroupField( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBase, BaseModel +): + typename: Literal["GroupField"] = Field(alias="__typename", default="GroupField") + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseHierarchyField( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBase, BaseModel +): + typename: Literal["HierarchyField"] = Field( + alias="__typename", default="HierarchyField" + ) + + +class GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseSetField( + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBase, BaseModel +): + typename: Literal["SetField"] = Field(alias="__typename", default="SetField") + + +class GetItems_sheetsConnectionSheetsconnectionNodes(BaseModel): + """A sheet contained in a published workbook.""" + + typename: Literal["Sheet"] = Field(alias="__typename", default="Sheet") + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + path: Optional[str] = Field(default=None) + "Server path to sheet" + luid: str + "Locally unique identifier used for the REST API on the Tableau Server (Blank if worksheet is hidden in Workbook)" + created_at: datetime = Field(alias="createdAt") + "Time the sheet was created" + updated_at: datetime = Field(alias="updatedAt") + "Time the sheet was updated" + tags: List[GetItems_sheetsConnectionSheetsconnectionNodesTags] + "Tags associated with the view" + contained_in_dashboards: Optional[ + List[ + Optional[ + GetItems_sheetsConnectionSheetsconnectionNodesContainedindashboards + ] + ] + ] = Field(default=None, alias="containedInDashboards") + "Dashboards that contain this sheet" + workbook: Optional[GetItems_sheetsConnectionSheetsconnectionNodesWorkbook] = Field( + default=None + ) + "The workbook that contains this view" + datasource_fields: Optional[ + List[ + Optional[ + Annotated[ + Union[ + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseBinField, + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseCalculatedField, + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseColumnField, + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseCombinedField, + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseCombinedSetField, + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseDatasourceField, + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseGroupField, + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseHierarchyField, + GetItems_sheetsConnectionSheetsconnectionNodesDatasourcefieldsBaseSetField, + ], + Field(discriminator="typename"), + ] + ] + ] + ] = Field(default=None, alias="datasourceFields") + "Fields that are contained in an embedded data source and are also referenced by the worksheet. If a worksheet uses calculated fields (or any other FieldReferencingField), this list will also include all of the referenced fields." + + +class GetItems_sheetsConnectionSheetsconnectionPageinfo(BaseModel): + """Information about pagination in a connection""" + + typename: Literal["PageInfo"] = Field(alias="__typename", default="PageInfo") + has_next_page: bool = Field(alias="hasNextPage") + "Indicates if there are more objects to fetch" + end_cursor: Optional[str] = Field(default=None, alias="endCursor") + "Cursor to use in subsequent query to fetch next page of objects" + + +class GetItems_sheetsConnectionSheetsconnection(BaseModel): + """Connection Type for Sheet""" + + typename: Literal["SheetsConnection"] = Field( + alias="__typename", default="SheetsConnection" + ) + nodes: List[GetItems_sheetsConnectionSheetsconnectionNodes] + "List of nodes" + page_info: GetItems_sheetsConnectionSheetsconnectionPageinfo = Field( + alias="pageInfo" + ) + "Information for pagination" + + +class GetItems_sheetsConnection(BaseModel): + sheets_connection: GetItems_sheetsConnectionSheetsconnection = Field( + alias="sheetsConnection" + ) + "Fetch Sheets with support for pagination" + + class Arguments(BaseModel): + first: Optional[int] = Field(default=None) + after: Optional[str] = Field(default=None) + + class Meta: + document = 'query GetItems_sheetsConnection($first: Int, $after: String) {\n sheetsConnection(\n first: $first\n after: $after\n filter: {idWithin: ["fa9e30e8-645e-1105-642d-c292c70a921c", "cea027c2-24a2-d009-4ccf-ac172a3fac6e", "b4f94b9f-26dc-3fb3-1973-796e4c91cb21", "f6682a87-7396-f12e-2fd1-0424157c6ceb", "8fb398c1-0b18-528a-c3bd-2a03c35528f5", "ffe3435f-3e0b-9618-389c-055cbed13ac9", "4e51108f-3ba4-0749-6518-8104fc62c202", "67f86c94-c102-447a-8752-b1e497bf4551", "cbb0b196-5f2a-ecd4-0b2b-e87db220ff47", "1359177d-c634-2cff-4408-1751152c7fc2"]}\n ) {\n nodes {\n id\n name\n path\n luid\n createdAt\n updatedAt\n tags {\n name\n __typename\n }\n containedInDashboards {\n name\n path\n __typename\n }\n workbook {\n id\n name\n projectName\n luid\n owner {\n username\n __typename\n }\n __typename\n }\n datasourceFields {\n __typename\n id\n name\n description\n datasource {\n id\n name\n __typename\n }\n ... on ColumnField {\n dataCategory\n role\n dataType\n aggregation\n }\n ... on CalculatedField {\n role\n dataType\n aggregation\n formula\n }\n ... on GroupField {\n role\n dataType\n }\n ... on DatasourceField {\n remoteField {\n __typename\n id\n name\n description\n folderName\n ... on ColumnField {\n dataCategory\n role\n dataType\n aggregation\n }\n ... on CalculatedField {\n role\n dataType\n aggregation\n formula\n }\n ... on GroupField {\n role\n dataType\n }\n }\n }\n }\n __typename\n }\n pageInfo {\n hasNextPage\n endCursor\n __typename\n }\n __typename\n }\n}' + + +class GetItems_workbooksConnectionWorkbooksconnectionNodesOwner(BaseModel): + """User on a site on Tableau server""" + + typename: Literal["TableauUser"] = Field(alias="__typename", default="TableauUser") + username: Optional[str] = Field(default=None) + "Username of this user" + + +class GetItems_workbooksConnectionWorkbooksconnectionNodesTags(BaseModel): + """A tag associated with content items""" + + typename: Literal["Tag"] = Field(alias="__typename", default="Tag") + name: Optional[str] = Field(default=None) + "The name of the tag" + + +class GetItems_workbooksConnectionWorkbooksconnectionNodesSheets(BaseModel): + """A sheet contained in a published workbook.""" + + typename: Literal["Sheet"] = Field(alias="__typename", default="Sheet") + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + + +class GetItems_workbooksConnectionWorkbooksconnectionNodesDashboards(BaseModel): + """A dashboard contained in a published workbook.""" + + typename: Literal["Dashboard"] = Field(alias="__typename", default="Dashboard") + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + + +class GetItems_workbooksConnectionWorkbooksconnectionNodesEmbeddeddatasources( + BaseModel +): + """A data source embedded in a workbook""" + + typename: Literal["EmbeddedDatasource"] = Field( + alias="__typename", default="EmbeddedDatasource" + ) + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + + +class GetItems_workbooksConnectionWorkbooksconnectionNodes(BaseModel): + """Workbooks are used to package up Tableau visualizations (which are called "sheets" in the Metadata API) and data models (which are called "embedded data sources" when they are owned by a workbook).""" + + typename: Literal["Workbook"] = Field(alias="__typename", default="Workbook") + id: str + "Unique identifier used by the metadata API. Not the same as the numeric ID used on server" + name: Optional[str] = Field(default=None) + "Name shown in server and desktop clients" + luid: str + "Locally unique identifier used for the REST API on the Tableau Server" + uri: Optional[str] = Field(default=None) + "Uri of the workbook" + project_name: Optional[str] = Field(default=None, alias="projectName") + "The name of the project in which the workbook is visible and usable." + owner: GetItems_workbooksConnectionWorkbooksconnectionNodesOwner + "User who owns this workbook" + description: Optional[str] = Field(default=None) + "Description of the workbook" + uri: Optional[str] = Field(default=None) + "Uri of the workbook" + created_at: datetime = Field(alias="createdAt") + "Time the workbook was created" + updated_at: datetime = Field(alias="updatedAt") + "Time the workbook was updated" + tags: List[GetItems_workbooksConnectionWorkbooksconnectionNodesTags] + "Tags associated with the workbook" + sheets: List[GetItems_workbooksConnectionWorkbooksconnectionNodesSheets] + "Worksheets that are contained in this workbook" + dashboards: List[GetItems_workbooksConnectionWorkbooksconnectionNodesDashboards] + "Dashboards that are contained in this workbook" + embedded_datasources: List[ + GetItems_workbooksConnectionWorkbooksconnectionNodesEmbeddeddatasources + ] = Field(alias="embeddedDatasources") + "Data sources that are embedded in this workbook" + + +class GetItems_workbooksConnectionWorkbooksconnectionPageinfo(BaseModel): + """Information about pagination in a connection""" + + typename: Literal["PageInfo"] = Field(alias="__typename", default="PageInfo") + has_next_page: bool = Field(alias="hasNextPage") + "Indicates if there are more objects to fetch" + end_cursor: Optional[str] = Field(default=None, alias="endCursor") + "Cursor to use in subsequent query to fetch next page of objects" + + +class GetItems_workbooksConnectionWorkbooksconnection(BaseModel): + """Connection Type for Workbook""" + + typename: Literal["WorkbooksConnection"] = Field( + alias="__typename", default="WorkbooksConnection" + ) + nodes: List[GetItems_workbooksConnectionWorkbooksconnectionNodes] + "List of nodes" + page_info: GetItems_workbooksConnectionWorkbooksconnectionPageinfo = Field( + alias="pageInfo" + ) + "Information for pagination" + + +class GetItems_workbooksConnection(BaseModel): + workbooks_connection: GetItems_workbooksConnectionWorkbooksconnection = Field( + alias="workbooksConnection" + ) + "Fetch Workbooks with support for pagination" + + class Arguments(BaseModel): + first: Optional[int] = Field(default=None) + after: Optional[str] = Field(default=None) + + class Meta: + document = 'query GetItems_workbooksConnection($first: Int, $after: String) {\n workbooksConnection(\n first: $first\n after: $after\n filter: {projectNameWithin: ["project_test2"]}\n ) {\n nodes {\n id\n name\n luid\n uri\n projectName\n owner {\n username\n __typename\n }\n description\n uri\n createdAt\n updatedAt\n tags {\n name\n __typename\n }\n sheets {\n id\n __typename\n }\n dashboards {\n id\n __typename\n }\n embeddedDatasources {\n id\n __typename\n }\n __typename\n }\n pageInfo {\n hasNextPage\n endCursor\n __typename\n }\n __typename\n }\n}' diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/tableau.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/tableau.py index 36e62c928744e..638af147ddb6f 100644 --- a/metadata-ingestion/src/datahub/ingestion/source/tableau/tableau.py +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/tableau.py @@ -90,6 +90,9 @@ StatefulIngestionSourceBase, ) from datahub.ingestion.source.tableau import tableau_constant as c +from datahub.ingestion.source.tableau.codegen_turms.schema import ( + GetItems_workbooksConnection, +) from datahub.ingestion.source.tableau.tableau_common import ( FIELD_TYPE_MAPPING, MetadataQueryException, @@ -940,6 +943,237 @@ def get_workunits_internal(self) -> Iterable[MetadataWorkUnit]: if self.server is None or not self.server.is_signed_in(): return try: + # TURMS + + # mypy errors + # + # src/datahub/ingestion/source/tableau/codegen_turms/schema.py:233: error: Incompatible types in assignment (expression has type "str | None", base class "BaseModel" defined the type as "Callable[[type[BaseModel], bool, str], dict[str, Any]]") [assignment] + # src/datahub/ingestion/source/tableau/codegen_turms/schema.py:405: error: Incompatible types in assignment (expression has type "str | None", base class "BaseModel" defined the type as "Callable[[type[BaseModel], bool, str], dict[str, Any]]") [assignment] + # src/datahub/ingestion/source/tableau/codegen_turms/schema.py:631: error: Incompatible types in assignment (expression has type "str | None", base class "BaseModel" defined the type as "Callable[[type[BaseModel], bool, str], dict[str, Any]]") [assignment] + # src/datahub/ingestion/source/tableau/codegen_turms/schema.py:1270: error: Incompatible types in assignment (expression has type "str | None", base class "BaseModel" defined the type as "Callable[[type[BaseModel], bool, str], dict[str, Any]]") [assignment] + # src/datahub/ingestion/source/tableau/codegen_turms/schema.py:1814: error: Name "uri" already defined (possibly by an import) [no-redef] + # src/datahub/ingestion/source/tableau/codegen_turms/schema.py:1832: error: Name "uri" already defined on line 1824 [no-redef] + + # execution error + # + # NameError: Field name "schema" shadows a BaseModel attribute; use a different field name with "alias='schema'". + + variables = GetItems_workbooksConnection.Arguments(first=100, after=None) + logger.info( + f"[[TURMS]] Query: {GetItems_workbooksConnection.Meta.document} Variables: {variables.json()}" + ) + result = self.server.metadata.query( + query=GetItems_workbooksConnection.Meta.document, + variables=variables.json(), + ) + logger.info(f"[[TURMS]] Tableau Workbooks: {result}") + + # After some manual edits to fix the 'schema' field issue and ignoring mypy errors + + # -[2025-01-29 17:41:24,631] INFO {datahub.ingestion.source.tableau.tableau:962} - [[TURMS]] Query: query GetItems_workbooksConnection($first: Int, $after: String) { + # workbooksConnection( + # first: $first + # after: $after + # filter: {projectNameWithin: ["project_test2"]} + # ) { + # nodes { + # id + # name + # luid + # uri + # projectName + # owner { + # username + # __typename + # } + # description + # uri + # createdAt + # updatedAt + # tags { + # name + # __typename + # } + # sheets { + # id + # __typename + # } + # dashboards { + # id + # __typename + # } + # embeddedDatasources { + # id + # __typename + # } + # __typename + # } + # pageInfo { + # hasNextPage + # endCursor + # __typename + # } + # __typename + # } + # } Variables: {"first": 100, "after": null} + # [2025-01-29 17:41:25,070] INFO {datahub.ingestion.source.tableau.tableau:967} - [[TURMS]] Tableau Workbooks: {'data': {'workbooksConnection': {'nodes': [{'id': '280d3fd0-c431-30c3-2e8f-c2620a4f472e', 'name': 'customer_profit_wb', 'luid': '3c6b22b8-5c42-413f-9505-f5d4715413db', 'uri': 'sites/71413/workbooks/2782740', 'projectName': 'project_test2', 'owner': {'username': 'harshal@acryl.io', '__typename': 'TableauUser'}, 'description': '', 'createdAt': '2024-09-03T04:36:19Z', 'updatedAt': '2024-09-03T04:36:19Z', 'tags': [], 'sheets': [{'id': 'aa141b11-a1ae-fef6-4a25-28b85d62b3f4', '__typename': 'Sheet'}], 'dashboards': [], 'embeddedDatasources': [{'id': 'a00e6ea7-64f5-f999-9967-236609717f86', '__typename': 'EmbeddedDatasource'}], '__typename': 'Workbook'}], 'pageInfo': {'hasNextPage': False, 'endCursor': None, '__typename': 'PageInfo'}, '__typename': 'WorkbooksConnection'}}} + + # SGQLC + + # mypy errors + # + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:37553: error: Incompatible types in assignment (expression has type tuple[str, str, str, str], base class "DataField" defined the type as tuple[str, str, ... <34 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:37668: error: Incompatible types in assignment (expression has type tuple[str, str, str, str, str, str], base class "AnalyticsField" defined the type as tuple[str, str, ... <35 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:37799: error: Incompatible types in assignment (expression has type "tuple[str, str, str, str, str]", base class "Certifiable" defined the type as "tuple[str, str, str, str, str, str]") [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:37830: error: Incompatible types in assignment (expression has type tuple[str, str, ... <60 more items>], base class "CanHaveLabels" defined the type as tuple[str, str, str, str, str]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:40573: error: Incompatible types in assignment (expression has type tuple[str, str], base class "AnalyticsField" defined the type as tuple[str, str, ... <35 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:40673: error: Incompatible types in assignment (expression has type tuple[()], base class "Field" defined the type as tuple[str, str, ... <84 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:40683: error: Incompatible types in assignment (expression has type tuple[str, str], base class "Field" defined the type as tuple[str, str, ... <84 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:40703: error: Incompatible types in assignment (expression has type tuple[str, str, str, str, str, str], base class "Table" defined the type as tuple[str, str, ... <40 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:40832: error: Incompatible types in assignment (expression has type tuple[str, str, ... <18 more items>], base class "Taggable" defined the type as tuple[str, str, str, str, str]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:41803: error: Incompatible types in assignment (expression has type "tuple[()]", base class "CanHaveLabels" defined the type as "tuple[str, str, str, str, str]") [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:41810: error: Incompatible types in assignment (expression has type tuple[()], base class "Label" defined the type as tuple[str, str, ... <11 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:41817: error: Incompatible types in assignment (expression has type tuple[str, str], base class "Label" defined the type as tuple[str, str, ... <11 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:41835: error: Incompatible types in assignment (expression has type "tuple[str, str, str, str]", base class "CanHaveLabels" defined the type as "tuple[str, str, str, str, str]") [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:41859: error: Incompatible types in assignment (expression has type tuple[str, str, ... <18 more items>], base class "CanHaveLabels" defined the type as tuple[str, str, str, str, str]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:42343: error: Incompatible types in assignment (expression has type tuple[str], base class "Field" defined the type as tuple[str, str, ... <84 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:42355: error: Incompatible types in assignment (expression has type tuple[str, str, ... <11 more items>], base class "Datasource" defined the type as tuple[str, str, ... <26 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:42968: error: Incompatible types in assignment (expression has type "tuple[str]", base class "CanHaveLabels" defined the type as "tuple[str, str, str, str, str]") [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:42979: error: Incompatible types in assignment (expression has type tuple[str, str, ... <67 more items>], base class "CanHaveLabels" defined the type as tuple[str, str, str, str, str]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:45832: error: Incompatible types in assignment (expression has type tuple[str, str], base class "FlowInputField" defined the type as tuple[str, str, ... <11 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:45844: error: Incompatible types in assignment (expression has type tuple[str, str], base class "FlowOutputField" defined the type as tuple[str, str, ... <43 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:45856: error: Incompatible types in assignment (expression has type tuple[str, str], base class "FlowInputField" defined the type as tuple[str, str, ... <11 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:45868: error: Incompatible types in assignment (expression has type tuple[str, str], base class "FlowOutputField" defined the type as tuple[str, str, ... <43 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:45882: error: Incompatible types in assignment (expression has type tuple[()], base class "Label" defined the type as tuple[str, str, ... <11 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:45892: error: Incompatible types in assignment (expression has type tuple[str], base class "DataField" defined the type as tuple[str, str, ... <34 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:45907: error: Incompatible types in assignment (expression has type tuple[()], base class "Field" defined the type as tuple[str, str, ... <84 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:45916: error: Incompatible types in assignment (expression has type tuple[str, str, ... <35 more items>], base class "Taggable" defined the type as tuple[str, str, str, str, str]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:47275: error: Incompatible types in assignment (expression has type tuple[str, str, ... <43 more items>], base class "CanHaveLabels" defined the type as tuple[str, str, str, str, str]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:48964: error: Incompatible types in assignment (expression has type tuple[str, str], base class "Field" defined the type as tuple[str, str, ... <84 more items>]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:49068: error: Incompatible types in assignment (expression has type tuple[str, str, ... <20 more items>], base class "Taggable" defined the type as tuple[str, str, str, str, str]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:50163: error: Incompatible types in assignment (expression has type tuple[str, str, ... <47 more items>], base class "CanHaveLabels" defined the type as tuple[str, str, str, str, str]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:52039: error: Incompatible types in assignment (expression has type tuple[str, str, ... <13 more items>], base class "CanHaveLabels" defined the type as tuple[str, str, str, str, str]) [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:52402: error: Incompatible types in assignment (expression has type "tuple[str]", base class "CanHaveLabels" defined the type as "tuple[str, str, str, str, str]") [assignment] + # src/datahub/ingestion/source/tableau/codegen_sgqlc/tableau_schema.py:52414: error: Incompatible types in assignment (expression has type tuple[str, str, ... <43 more items>], base class "Taggable" defined the type as tuple[str, str, str, str, str]) [assignment] + + from datahub.ingestion.source.tableau.codegen_sgqlc.tableau_operations import ( + Operations, + ) + + op = Operations.query.get_items_workbooks_connection + logger.info( + f"[[SGQLC]] Query: {op} Variables: {dict(first=100, after=None)}" + ) + result = self.server.metadata.query( + query=str(op), variables=dict(first=100, after=None) + ) + logger.info(f"[[SGQLC]] Result: {result}") + + # [2025-01-29 17:41:25,119] INFO {datahub.ingestion.source.tableau.tableau:1015} - [[SGQLC]] Query: query GetItems_workbooksConnection($first: Int, $after: String) { + # workbooksConnection(first: $first, after: $after, filter: {projectNameWithin: ["project_test2"]}) { + # nodes { + # id + # name + # luid + # uri + # projectName + # owner { + # username + # } + # description + # createdAt + # updatedAt + # tags { + # name + # } + # sheets { + # id + # } + # dashboards { + # id + # } + # embeddedDatasources { + # id + # } + # } + # pageInfo { + # hasNextPage + # endCursor + # } + # } + # } Variables: {'first': 100, 'after': None} + # [2025-01-29 17:41:25,568] INFO {datahub.ingestion.source.tableau.tableau:1020} - [[SGQLC]] Result: {'data': {'workbooksConnection': {'nodes': [{'id': '280d3fd0-c431-30c3-2e8f-c2620a4f472e', 'name': 'customer_profit_wb', 'luid': '3c6b22b8-5c42-413f-9505-f5d4715413db', 'uri': 'sites/71413/workbooks/2782740', 'projectName': 'project_test2', 'owner': {'username': 'harshal@acryl.io'}, 'description': '', 'createdAt': '2024-09-03T04:36:19Z', 'updatedAt': '2024-09-03T04:36:19Z', 'tags': [], 'sheets': [{'id': 'aa141b11-a1ae-fef6-4a25-28b85d62b3f4'}], 'dashboards': [], 'embeddedDatasources': [{'id': 'a00e6ea7-64f5-f999-9967-236609717f86'}]}], 'pageInfo': {'hasNextPage': False, 'endCursor': None}}}} + + # ARIADNE + + # mypy errors + # + # src/datahub/ingestion/source/tableau/codegen_ariadne/base_model.py:17: error: Extra keys ("populate_by_name", "protected_namespaces") for TypedDict "ConfigDict" [typeddict-unknown-key] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py:24: error: Name "uri" already defined (possibly by an import) [no-redef] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py:32: error: Name "uri" already defined on line 28 [no-redef] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py:68: error: "type[GetItemsWorkbooksConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py:69: error: "type[GetItemsWorkbooksConnectionWorkbooksConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py:70: error: "type[GetItemsWorkbooksConnectionWorkbooksConnectionNodes]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py:283: error: "type[GetItemsSheetsConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py:284: error: "type[GetItemsSheetsConnectionSheetsConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py:285: error: "type[GetItemsSheetsConnectionSheetsConnectionNodes]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py:286: error: "type[GetItemsSheetsConnectionSheetsConnectionNodesWorkbook]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py:287: error: "type[GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsField]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py:288: error: "type[GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsCalculatedField]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py:289: error: "type[GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsColumnField]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py:290: error: "type[GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsDatasourceField]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_sheets_connection.py:291: error: "type[GetItemsSheetsConnectionSheetsConnectionNodesDatasourceFieldsGroupField]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_published_datasources_connection.py:190: error: "type[GetItemsPublishedDatasourcesConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_published_datasources_connection.py:191: error: "type[GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_published_datasources_connection.py:192: error: "type[GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodes]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_published_datasources_connection.py:193: error: "type[GetItemsPublishedDatasourcesConnectionPublishedDatasourcesConnectionNodesUpstreamTables]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_fields_connection.py:89: error: "type[GetItemsFieldsConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_fields_connection.py:90: error: "type[GetItemsFieldsConnectionFieldsConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_fields_connection.py:91: error: "type[GetItemsFieldsConnectionFieldsConnectionNodes]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_fields_connection.py:92: error: "type[GetItemsFieldsConnectionFieldsConnectionNodesUpstreamFields]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_fields_connection.py:93: error: "type[GetItemsFieldsConnectionFieldsConnectionNodesUpstreamColumns]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_embedded_datasources_connection.py:207: error: "type[GetItemsEmbeddedDatasourcesConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_embedded_datasources_connection.py:208: error: "type[GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_embedded_datasources_connection.py:209: error: "type[GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodes]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_embedded_datasources_connection.py:210: error: "type[GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesUpstreamTables]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_embedded_datasources_connection.py:211: error: "type[GetItemsEmbeddedDatasourcesConnectionEmbeddedDatasourcesConnectionNodesWorkbook]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_database_tables_connection.py:43: error: "type[GetItemsDatabaseTablesConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_database_tables_connection.py:44: error: "type[GetItemsDatabaseTablesConnectionDatabaseTablesConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_database_tables_connection.py:45: error: "type[GetItemsDatabaseTablesConnectionDatabaseTablesConnectionNodes]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:258: error: "type[GetItemsCustomSQLTablesConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:259: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnection]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:260: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodes]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:261: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumns]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:262: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFields]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:263: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceDatasource]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:264: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceDatasourceUpstreamTables]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:265: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasource]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:266: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourceEmbeddedDatasourceUpstreamTables]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:267: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourcePublishedDatasource]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:268: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesColumnsReferencedByFieldsDatasourcePublishedDatasourceUpstreamTables]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_custom_sql_tables_connection.py:269: error: "type[GetItemsCustomSQLTablesConnectionCustomSqlTablesConnectionNodesTables]" has no attribute "model_rebuild" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/async_base_client.py:21: error: Module "websockets.client" has no attribute "WebSocketClientProtocol"; maybe "ClientProtocol"? [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/async_base_client.py:21: note: Error code "attr-defined" not covered by "type: ignore" comment + # src/datahub/ingestion/source/tableau/codegen_ariadne/async_base_client.py:21: error: Module "websockets.client" has no attribute "connect" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/async_base_client.py:209: error: "BaseModel" has no attribute "model_dump" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/client.py:76: error: "type[GetItemsDatabaseTablesConnection]" has no attribute "model_validate" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/client.py:173: error: "type[GetItemsCustomSQLTablesConnection]" has no attribute "model_validate" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/client.py:266: error: "type[GetItemsPublishedDatasourcesConnection]" has no attribute "model_validate" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/client.py:317: error: "type[GetItemsFieldsConnection]" has no attribute "model_validate" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/client.py:417: error: "type[GetItemsEmbeddedDatasourcesConnection]" has no attribute "model_validate" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/client.py:525: error: "type[GetItemsSheetsConnection]" has no attribute "model_validate" [attr-defined] + # src/datahub/ingestion/source/tableau/codegen_ariadne/client.py:583: error: "type[GetItemsWorkbooksConnection]" has no attribute "model_validate" [attr-defined] + + from datahub.ingestion.source.tableau.codegen_ariadne.get_items_workbooks_connection import ( + GetItemsWorkbooksConnection as GetItemsWorkbooksConnectionAriadne, + ) + + op = GetItemsWorkbooksConnectionAriadne() + + logger.info( + f"[[ARIADNE]] Query: {op} Variables: {dict(first=100, after=None)}" + ) + if self.config.ingest_multiple_sites: for site in list(TSC.Pager(self.server.sites)): if ( From 0a142d66af07cb15aff17c3526faf2a738b55d00 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sergio=20G=C3=B3mez=20Villamor?= Date: Thu, 30 Jan 2025 13:47:42 +0100 Subject: [PATCH 2/2] deserialization --- .../source/tableau/codegen_ariadne/client.py | 1021 +++++++++-------- .../get_items_workbooks_connection.py | 6 +- .../source/tableau/codegen_turms/schema.py | 8 +- .../ingestion/source/tableau/tableau.py | 85 +- 4 files changed, 594 insertions(+), 526 deletions(-) diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/client.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/client.py index fd17d6ae847ca..86b83b7b722f7 100644 --- a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/client.py +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/client.py @@ -1,30 +1,32 @@ # Generated by ariadne-codegen # Source: ./tableau-queries.graphql +import logging from typing import Any, Dict, Optional, Union from datahub.ingestion.source.tableau.codegen_ariadne.async_base_client import ( AsyncBaseClient, ) from datahub.ingestion.source.tableau.codegen_ariadne.base_model import UNSET, UnsetType -from datahub.ingestion.source.tableau.codegen_ariadne.get_items_custom_sql_tables_connection import ( - GetItemsCustomSQLTablesConnection, -) -from datahub.ingestion.source.tableau.codegen_ariadne.get_items_database_tables_connection import ( - GetItemsDatabaseTablesConnection, -) -from datahub.ingestion.source.tableau.codegen_ariadne.get_items_embedded_datasources_connection import ( - GetItemsEmbeddedDatasourcesConnection, -) -from datahub.ingestion.source.tableau.codegen_ariadne.get_items_fields_connection import ( - GetItemsFieldsConnection, -) -from datahub.ingestion.source.tableau.codegen_ariadne.get_items_published_datasources_connection import ( - GetItemsPublishedDatasourcesConnection, -) -from datahub.ingestion.source.tableau.codegen_ariadne.get_items_sheets_connection import ( - GetItemsSheetsConnection, -) + +# !!! from datahub.ingestion.source.tableau.codegen_ariadne.get_items_custom_sql_tables_connection import ( +# !!! GetItemsCustomSQLTablesConnection, +# !!! ) +# !!! from datahub.ingestion.source.tableau.codegen_ariadne.get_items_database_tables_connection import ( +# !!! GetItemsDatabaseTablesConnection, +# !!! ) +# !!! from datahub.ingestion.source.tableau.codegen_ariadne.get_items_embedded_datasources_connection import ( +# !!! GetItemsEmbeddedDatasourcesConnection, +# !!! ) +# !!! from datahub.ingestion.source.tableau.codegen_ariadne.get_items_fields_connection import ( +# !!! GetItemsFieldsConnection, +# !!! ) +# !!! from datahub.ingestion.source.tableau.codegen_ariadne.get_items_published_datasources_connection import ( +# !!! GetItemsPublishedDatasourcesConnection, +# !!! ) +# !!! from datahub.ingestion.source.tableau.codegen_ariadne.get_items_sheets_connection import ( +# !!! GetItemsSheetsConnection, +# !!! ) from datahub.ingestion.source.tableau.codegen_ariadne.get_items_workbooks_connection import ( GetItemsWorkbooksConnection, ) @@ -34,495 +36,498 @@ def gql(q: str) -> str: return q -class Client(AsyncBaseClient): - async def get_items_database_tables_connection( - self, - first: Union[Optional[int], UnsetType] = UNSET, - after: Union[Optional[str], UnsetType] = UNSET, - **kwargs: Any, - ) -> GetItemsDatabaseTablesConnection: - query = gql( - """ - query GetItems_databaseTablesConnection($first: Int, $after: String) { - databaseTablesConnection( - first: $first - after: $after - filter: {idWithin: ["76e2151b-124f-7ec8-896b-dd107eafca05", "a1b165ad-c7c2-282d-94c5-1b8a877936ee", "2d3bdb4e-08da-a6da-fecb-a3c10abba357", "92b0a3ae-2fc9-1b42-47e0-c17d0f0b615a", "63ffbbfe-8c2d-c4f3-7a28-e11f247227c7", "06d776e1-9376-bc06-84d5-c7a5c4253bf5", "159ed86e-796f-3f13-8f07-3e63c271015e", "2f2ccb48-edd5-0e02-4d51-eb3b0819fbf1", "2fe499f7-9c5a-81ef-f32d-9553dcc86044", "4a34ada9-ed4a-089f-01d0-4a1f230ee2e6"]} - ) { - nodes { - id - isEmbedded - columns { - remoteType - name - } - } - pageInfo { - hasNextPage - endCursor - } - } - } - """ - ) - variables: Dict[str, object] = {"first": first, "after": after} - response = await self.execute( - query=query, - operation_name="GetItems_databaseTablesConnection", - variables=variables, - **kwargs, - ) - data = self.get_data(response) - return GetItemsDatabaseTablesConnection.model_validate(data) - - async def get_items_custom_sql_tables_connection( - self, - first: Union[Optional[int], UnsetType] = UNSET, - after: Union[Optional[str], UnsetType] = UNSET, - **kwargs: Any, - ) -> GetItemsCustomSQLTablesConnection: - query = gql( - """ - query GetItems_customSQLTablesConnection($first: Int, $after: String) { - customSQLTablesConnection( - first: $first - after: $after - filter: {idWithin: ["81335c49-5edc-bbfa-77c9-c4a1cd444501", "48c19c5f-4300-07bb-17ee-1fbdf6824ff6"]} - ) { - nodes { - id - name - query - columns { - id - name - remoteType - description - referencedByFields { - datasource { - __typename - id - name - upstreamTables { - id - name - database { - __typename - name - id - } - schema - fullName - connectionType - } - ... on PublishedDatasource { - projectName - luid - } - ... on EmbeddedDatasource { - workbook { - id - name - projectName - luid - } - } - } - } - } - tables { - id - name - database { - __typename - name - id - } - schema - fullName - connectionType - description - columnsConnection { - totalCount - } - } - connectionType - database { - __typename - name - id - connectionType - } - } - pageInfo { - hasNextPage - endCursor - } - } - } - """ - ) - variables: Dict[str, object] = {"first": first, "after": after} - response = await self.execute( - query=query, - operation_name="GetItems_customSQLTablesConnection", - variables=variables, - **kwargs, - ) - data = self.get_data(response) - return GetItemsCustomSQLTablesConnection.model_validate(data) - - async def get_items_published_datasources_connection( - self, - first: Union[Optional[int], UnsetType] = UNSET, - after: Union[Optional[str], UnsetType] = UNSET, - **kwargs: Any, - ) -> GetItemsPublishedDatasourcesConnection: - query = gql( - """ - query GetItems_publishedDatasourcesConnection($first: Int, $after: String) { - publishedDatasourcesConnection( - first: $first - after: $after - filter: {idWithin: ["35d62018-68e1-6ad4-2cf0-d3ede4ee9a67", "87d9d9d8-59a8-adc3-3e06-f75c5b98ec52", "ae8b52c9-1481-06fd-fe96-e6d4938f9fcb"]} - ) { - nodes { - __typename - id - name - luid - hasExtracts - extractLastRefreshTime - extractLastIncrementalUpdateTime - extractLastUpdateTime - upstreamTables { - id - name - database { - __typename - name - id - } - schema - fullName - connectionType - description - columnsConnection { - totalCount - } - } - fields { - __typename - id - name - description - isHidden - folderName - ... on ColumnField { - dataCategory - role - dataType - defaultFormat - aggregation - } - ... on CalculatedField { - role - dataType - defaultFormat - aggregation - formula - } - ... on GroupField { - role - dataType - } - } - owner { - username - } - description - uri - projectName - tags { - name - } - } - pageInfo { - hasNextPage - endCursor - } - } - } - """ - ) - variables: Dict[str, object] = {"first": first, "after": after} - response = await self.execute( - query=query, - operation_name="GetItems_publishedDatasourcesConnection", - variables=variables, - **kwargs, - ) - data = self.get_data(response) - return GetItemsPublishedDatasourcesConnection.model_validate(data) - - async def get_items_fields_connection( - self, - first: Union[Optional[int], UnsetType] = UNSET, - after: Union[Optional[str], UnsetType] = UNSET, - **kwargs: Any, - ) -> GetItemsFieldsConnection: - query = gql( - """ - query GetItems_fieldsConnection($first: Int, $after: String) { - fieldsConnection( - first: $first - after: $after - filter: {idWithin: ["668470bc-f0c9-ec5d-7a4b-172370d6ef45", "66bd48ba-a895-4951-a4e1-d26fc191eae9", "672a63ee-c34b-8cb4-506b-163fcb131a52", "72684adf-d214-0a9a-946c-dd7b3879b51f", "76636a30-dfbf-0107-0190-a0fc6ce201be", "77aa21d6-3b79-0be0-d309-3d36ef1efe71", "8fbf178a-ceef-2c97-3ac8-26f95a004d67", "968608d1-5da4-1a97-e96a-269010d4ef5b", "b5ae252a-c3c0-3a2d-c147-7a39a8de59ef", "bc1641b9-525d-00c5-f163-02519d46f0fd"]} - ) { - nodes { - __typename - id - upstreamFields { - __typename - name - datasource { - __typename - id - } - } - upstreamColumns { - name - table { - __typename - id - } - } - } - pageInfo { - hasNextPage - endCursor - } - } - } - """ - ) - variables: Dict[str, object] = {"first": first, "after": after} - response = await self.execute( - query=query, - operation_name="GetItems_fieldsConnection", - variables=variables, - **kwargs, - ) - data = self.get_data(response) - return GetItemsFieldsConnection.model_validate(data) +logger: logging.Logger = logging.getLogger(__name__) - async def get_items_embedded_datasources_connection( - self, - first: Union[Optional[int], UnsetType] = UNSET, - after: Union[Optional[str], UnsetType] = UNSET, - **kwargs: Any, - ) -> GetItemsEmbeddedDatasourcesConnection: - query = gql( - """ - query GetItems_embeddedDatasourcesConnection($first: Int, $after: String) { - embeddedDatasourcesConnection( - first: $first - after: $after - filter: {idWithin: ["7437c561-4e94-0283-3462-c6205c2288cd", "797a69b1-c32a-2fd4-62aa-99989c1858a6", "79871b17-d526-17be-df59-e001f7140924", "8f5e3006-6756-8eea-4fd3-44781cea1493", "1c5653d6-c448-0850-108b-5c78aeaf6b51", "6731f648-b756-31ea-fcdd-77309dd3b0c3", "6bd53e72-9fe4-ea86-3d23-14b826c13fa5", "3f46592d-f789-8f48-466e-69606990d589", "415ddd3e-be04-b466-bc7c-5678a4b0a733", "e9b47a00-12ff-72cc-9dfb-d34e0c65095d"]} - ) { - nodes { - __typename - id - name - hasExtracts - extractLastRefreshTime - extractLastIncrementalUpdateTime - extractLastUpdateTime - downstreamSheets { - name - id - } - upstreamTables { - id - name - database { - __typename - name - id - } - schema - fullName - connectionType - description - columnsConnection { - totalCount - } - } - fields { - __typename - id - name - description - isHidden - folderName - ... on ColumnField { - dataCategory - role - dataType - defaultFormat - aggregation - } - ... on CalculatedField { - role - dataType - defaultFormat - aggregation - formula - } - ... on GroupField { - role - dataType - } - } - upstreamDatasources { - id - name - } - workbook { - id - name - projectName - luid - owner { - username - } - } - } - pageInfo { - hasNextPage - endCursor - } - } - } - """ - ) - variables: Dict[str, object] = {"first": first, "after": after} - response = await self.execute( - query=query, - operation_name="GetItems_embeddedDatasourcesConnection", - variables=variables, - **kwargs, - ) - data = self.get_data(response) - return GetItemsEmbeddedDatasourcesConnection.model_validate(data) - async def get_items_sheets_connection( - self, - first: Union[Optional[int], UnsetType] = UNSET, - after: Union[Optional[str], UnsetType] = UNSET, - **kwargs: Any, - ) -> GetItemsSheetsConnection: - query = gql( - """ - query GetItems_sheetsConnection($first: Int, $after: String) { - sheetsConnection( - first: $first - after: $after - filter: {idWithin: ["fa9e30e8-645e-1105-642d-c292c70a921c", "cea027c2-24a2-d009-4ccf-ac172a3fac6e", "b4f94b9f-26dc-3fb3-1973-796e4c91cb21", "f6682a87-7396-f12e-2fd1-0424157c6ceb", "8fb398c1-0b18-528a-c3bd-2a03c35528f5", "ffe3435f-3e0b-9618-389c-055cbed13ac9", "4e51108f-3ba4-0749-6518-8104fc62c202", "67f86c94-c102-447a-8752-b1e497bf4551", "cbb0b196-5f2a-ecd4-0b2b-e87db220ff47", "1359177d-c634-2cff-4408-1751152c7fc2"]} - ) { - nodes { - id - name - path - luid - createdAt - updatedAt - tags { - name - } - containedInDashboards { - name - path - } - workbook { - id - name - projectName - luid - owner { - username - } - } - datasourceFields { - __typename - id - name - description - datasource { - __typename - id - name - } - ... on ColumnField { - dataCategory - role - dataType - aggregation - } - ... on CalculatedField { - role - dataType - aggregation - formula - } - ... on GroupField { - role - dataType - } - ... on DatasourceField { - remoteField { - __typename - id - name - description - folderName - ... on ColumnField { - dataCategory - role - dataType - aggregation - } - ... on CalculatedField { - role - dataType - aggregation - formula - } - ... on GroupField { - role - dataType - } - } - } - } - } - pageInfo { - hasNextPage - endCursor - } - } - } - """ - ) - variables: Dict[str, object] = {"first": first, "after": after} - response = await self.execute( - query=query, - operation_name="GetItems_sheetsConnection", - variables=variables, - **kwargs, - ) - data = self.get_data(response) - return GetItemsSheetsConnection.model_validate(data) +class Client(AsyncBaseClient): + # !!! async def get_items_database_tables_connection( + # !!! self, + # !!! first: Union[Optional[int], UnsetType] = UNSET, + # !!! after: Union[Optional[str], UnsetType] = UNSET, + # !!! **kwargs: Any, + # !!! ) -> GetItemsDatabaseTablesConnection: + # !!! query = gql( + # !!! """ + # !!! query GetItems_databaseTablesConnection($first: Int, $after: String) { + # !!! databaseTablesConnection( + # !!! first: $first + # !!! after: $after + # !!! filter: {idWithin: ["76e2151b-124f-7ec8-896b-dd107eafca05", "a1b165ad-c7c2-282d-94c5-1b8a877936ee", "2d3bdb4e-08da-a6da-fecb-a3c10abba357", "92b0a3ae-2fc9-1b42-47e0-c17d0f0b615a", "63ffbbfe-8c2d-c4f3-7a28-e11f247227c7", "06d776e1-9376-bc06-84d5-c7a5c4253bf5", "159ed86e-796f-3f13-8f07-3e63c271015e", "2f2ccb48-edd5-0e02-4d51-eb3b0819fbf1", "2fe499f7-9c5a-81ef-f32d-9553dcc86044", "4a34ada9-ed4a-089f-01d0-4a1f230ee2e6"]} + # !!! ) { + # !!! nodes { + # !!! id + # !!! isEmbedded + # !!! columns { + # !!! remoteType + # !!! name + # !!! } + # !!! } + # !!! pageInfo { + # !!! hasNextPage + # !!! endCursor + # !!! } + # !!! } + # !!! } + # !!! """ + # !!! ) + # !!! variables: Dict[str, object] = {"first": first, "after": after} + # !!! response = await self.execute( + # !!! query=query, + # !!! operation_name="GetItems_databaseTablesConnection", + # !!! variables=variables, + # !!! **kwargs, + # !!! ) + # !!! data = self.get_data(response) + # !!! return GetItemsDatabaseTablesConnection.model_validate(data) + # !!! + # !!! async def get_items_custom_sql_tables_connection( + # !!! self, + # !!! first: Union[Optional[int], UnsetType] = UNSET, + # !!! after: Union[Optional[str], UnsetType] = UNSET, + # !!! **kwargs: Any, + # !!! ) -> GetItemsCustomSQLTablesConnection: + # !!! query = gql( + # !!! """ + # !!! query GetItems_customSQLTablesConnection($first: Int, $after: String) { + # !!! customSQLTablesConnection( + # !!! first: $first + # !!! after: $after + # !!! filter: {idWithin: ["81335c49-5edc-bbfa-77c9-c4a1cd444501", "48c19c5f-4300-07bb-17ee-1fbdf6824ff6"]} + # !!! ) { + # !!! nodes { + # !!! id + # !!! name + # !!! query + # !!! columns { + # !!! id + # !!! name + # !!! remoteType + # !!! description + # !!! referencedByFields { + # !!! datasource { + # !!! __typename + # !!! id + # !!! name + # !!! upstreamTables { + # !!! id + # !!! name + # !!! database { + # !!! __typename + # !!! name + # !!! id + # !!! } + # !!! schema + # !!! fullName + # !!! connectionType + # !!! } + # !!! ... on PublishedDatasource { + # !!! projectName + # !!! luid + # !!! } + # !!! ... on EmbeddedDatasource { + # !!! workbook { + # !!! id + # !!! name + # !!! projectName + # !!! luid + # !!! } + # !!! } + # !!! } + # !!! } + # !!! } + # !!! tables { + # !!! id + # !!! name + # !!! database { + # !!! __typename + # !!! name + # !!! id + # !!! } + # !!! schema + # !!! fullName + # !!! connectionType + # !!! description + # !!! columnsConnection { + # !!! totalCount + # !!! } + # !!! } + # !!! connectionType + # !!! database { + # !!! __typename + # !!! name + # !!! id + # !!! connectionType + # !!! } + # !!! } + # !!! pageInfo { + # !!! hasNextPage + # !!! endCursor + # !!! } + # !!! } + # !!! } + # !!! """ + # !!! ) + # !!! variables: Dict[str, object] = {"first": first, "after": after} + # !!! response = await self.execute( + # !!! query=query, + # !!! operation_name="GetItems_customSQLTablesConnection", + # !!! variables=variables, + # !!! **kwargs, + # !!! ) + # !!! data = self.get_data(response) + # !!! return GetItemsCustomSQLTablesConnection.model_validate(data) + # !!! + # !!! async def get_items_published_datasources_connection( + # !!! self, + # !!! first: Union[Optional[int], UnsetType] = UNSET, + # !!! after: Union[Optional[str], UnsetType] = UNSET, + # !!! **kwargs: Any, + # !!! ) -> GetItemsPublishedDatasourcesConnection: + # !!! query = gql( + # !!! """ + # !!! query GetItems_publishedDatasourcesConnection($first: Int, $after: String) { + # !!! publishedDatasourcesConnection( + # !!! first: $first + # !!! after: $after + # !!! filter: {idWithin: ["35d62018-68e1-6ad4-2cf0-d3ede4ee9a67", "87d9d9d8-59a8-adc3-3e06-f75c5b98ec52", "ae8b52c9-1481-06fd-fe96-e6d4938f9fcb"]} + # !!! ) { + # !!! nodes { + # !!! __typename + # !!! id + # !!! name + # !!! luid + # !!! hasExtracts + # !!! extractLastRefreshTime + # !!! extractLastIncrementalUpdateTime + # !!! extractLastUpdateTime + # !!! upstreamTables { + # !!! id + # !!! name + # !!! database { + # !!! __typename + # !!! name + # !!! id + # !!! } + # !!! schema + # !!! fullName + # !!! connectionType + # !!! description + # !!! columnsConnection { + # !!! totalCount + # !!! } + # !!! } + # !!! fields { + # !!! __typename + # !!! id + # !!! name + # !!! description + # !!! isHidden + # !!! folderName + # !!! ... on ColumnField { + # !!! dataCategory + # !!! role + # !!! dataType + # !!! defaultFormat + # !!! aggregation + # !!! } + # !!! ... on CalculatedField { + # !!! role + # !!! dataType + # !!! defaultFormat + # !!! aggregation + # !!! formula + # !!! } + # !!! ... on GroupField { + # !!! role + # !!! dataType + # !!! } + # !!! } + # !!! owner { + # !!! username + # !!! } + # !!! description + # !!! uri + # !!! projectName + # !!! tags { + # !!! name + # !!! } + # !!! } + # !!! pageInfo { + # !!! hasNextPage + # !!! endCursor + # !!! } + # !!! } + # !!! } + # !!! """ + # !!! ) + # !!! variables: Dict[str, object] = {"first": first, "after": after} + # !!! response = await self.execute( + # !!! query=query, + # !!! operation_name="GetItems_publishedDatasourcesConnection", + # !!! variables=variables, + # !!! **kwargs, + # !!! ) + # !!! data = self.get_data(response) + # !!! return GetItemsPublishedDatasourcesConnection.model_validate(data) + # !!! + # !!! async def get_items_fields_connection( + # !!! self, + # !!! first: Union[Optional[int], UnsetType] = UNSET, + # !!! after: Union[Optional[str], UnsetType] = UNSET, + # !!! **kwargs: Any, + # !!! ) -> GetItemsFieldsConnection: + # !!! query = gql( + # !!! """ + # !!! query GetItems_fieldsConnection($first: Int, $after: String) { + # !!! fieldsConnection( + # !!! first: $first + # !!! after: $after + # !!! filter: {idWithin: ["668470bc-f0c9-ec5d-7a4b-172370d6ef45", "66bd48ba-a895-4951-a4e1-d26fc191eae9", "672a63ee-c34b-8cb4-506b-163fcb131a52", "72684adf-d214-0a9a-946c-dd7b3879b51f", "76636a30-dfbf-0107-0190-a0fc6ce201be", "77aa21d6-3b79-0be0-d309-3d36ef1efe71", "8fbf178a-ceef-2c97-3ac8-26f95a004d67", "968608d1-5da4-1a97-e96a-269010d4ef5b", "b5ae252a-c3c0-3a2d-c147-7a39a8de59ef", "bc1641b9-525d-00c5-f163-02519d46f0fd"]} + # !!! ) { + # !!! nodes { + # !!! __typename + # !!! id + # !!! upstreamFields { + # !!! __typename + # !!! name + # !!! datasource { + # !!! __typename + # !!! id + # !!! } + # !!! } + # !!! upstreamColumns { + # !!! name + # !!! table { + # !!! __typename + # !!! id + # !!! } + # !!! } + # !!! } + # !!! pageInfo { + # !!! hasNextPage + # !!! endCursor + # !!! } + # !!! } + # !!! } + # !!! """ + # !!! ) + # !!! variables: Dict[str, object] = {"first": first, "after": after} + # !!! response = await self.execute( + # !!! query=query, + # !!! operation_name="GetItems_fieldsConnection", + # !!! variables=variables, + # !!! **kwargs, + # !!! ) + # !!! data = self.get_data(response) + # !!! return GetItemsFieldsConnection.model_validate(data) + # !!! + # !!! async def get_items_embedded_datasources_connection( + # !!! self, + # !!! first: Union[Optional[int], UnsetType] = UNSET, + # !!! after: Union[Optional[str], UnsetType] = UNSET, + # !!! **kwargs: Any, + # !!! ) -> GetItemsEmbeddedDatasourcesConnection: + # !!! query = gql( + # !!! """ + # !!! query GetItems_embeddedDatasourcesConnection($first: Int, $after: String) { + # !!! embeddedDatasourcesConnection( + # !!! first: $first + # !!! after: $after + # !!! filter: {idWithin: ["7437c561-4e94-0283-3462-c6205c2288cd", "797a69b1-c32a-2fd4-62aa-99989c1858a6", "79871b17-d526-17be-df59-e001f7140924", "8f5e3006-6756-8eea-4fd3-44781cea1493", "1c5653d6-c448-0850-108b-5c78aeaf6b51", "6731f648-b756-31ea-fcdd-77309dd3b0c3", "6bd53e72-9fe4-ea86-3d23-14b826c13fa5", "3f46592d-f789-8f48-466e-69606990d589", "415ddd3e-be04-b466-bc7c-5678a4b0a733", "e9b47a00-12ff-72cc-9dfb-d34e0c65095d"]} + # !!! ) { + # !!! nodes { + # !!! __typename + # !!! id + # !!! name + # !!! hasExtracts + # !!! extractLastRefreshTime + # !!! extractLastIncrementalUpdateTime + # !!! extractLastUpdateTime + # !!! downstreamSheets { + # !!! name + # !!! id + # !!! } + # !!! upstreamTables { + # !!! id + # !!! name + # !!! database { + # !!! __typename + # !!! name + # !!! id + # !!! } + # !!! schema + # !!! fullName + # !!! connectionType + # !!! description + # !!! columnsConnection { + # !!! totalCount + # !!! } + # !!! } + # !!! fields { + # !!! __typename + # !!! id + # !!! name + # !!! description + # !!! isHidden + # !!! folderName + # !!! ... on ColumnField { + # !!! dataCategory + # !!! role + # !!! dataType + # !!! defaultFormat + # !!! aggregation + # !!! } + # !!! ... on CalculatedField { + # !!! role + # !!! dataType + # !!! defaultFormat + # !!! aggregation + # !!! formula + # !!! } + # !!! ... on GroupField { + # !!! role + # !!! dataType + # !!! } + # !!! } + # !!! upstreamDatasources { + # !!! id + # !!! name + # !!! } + # !!! workbook { + # !!! id + # !!! name + # !!! projectName + # !!! luid + # !!! owner { + # !!! username + # !!! } + # !!! } + # !!! } + # !!! pageInfo { + # !!! hasNextPage + # !!! endCursor + # !!! } + # !!! } + # !!! } + # !!! """ + # !!! ) + # !!! variables: Dict[str, object] = {"first": first, "after": after} + # !!! response = await self.execute( + # !!! query=query, + # !!! operation_name="GetItems_embeddedDatasourcesConnection", + # !!! variables=variables, + # !!! **kwargs, + # !!! ) + # !!! data = self.get_data(response) + # !!! return GetItemsEmbeddedDatasourcesConnection.model_validate(data) + # !!! + # !!! async def get_items_sheets_connection( + # !!! self, + # !!! first: Union[Optional[int], UnsetType] = UNSET, + # !!! after: Union[Optional[str], UnsetType] = UNSET, + # !!! **kwargs: Any, + # !!! ) -> GetItemsSheetsConnection: + # !!! query = gql( + # !!! """ + # !!! query GetItems_sheetsConnection($first: Int, $after: String) { + # !!! sheetsConnection( + # !!! first: $first + # !!! after: $after + # !!! filter: {idWithin: ["fa9e30e8-645e-1105-642d-c292c70a921c", "cea027c2-24a2-d009-4ccf-ac172a3fac6e", "b4f94b9f-26dc-3fb3-1973-796e4c91cb21", "f6682a87-7396-f12e-2fd1-0424157c6ceb", "8fb398c1-0b18-528a-c3bd-2a03c35528f5", "ffe3435f-3e0b-9618-389c-055cbed13ac9", "4e51108f-3ba4-0749-6518-8104fc62c202", "67f86c94-c102-447a-8752-b1e497bf4551", "cbb0b196-5f2a-ecd4-0b2b-e87db220ff47", "1359177d-c634-2cff-4408-1751152c7fc2"]} + # !!! ) { + # !!! nodes { + # !!! id + # !!! name + # !!! path + # !!! luid + # !!! createdAt + # !!! updatedAt + # !!! tags { + # !!! name + # !!! } + # !!! containedInDashboards { + # !!! name + # !!! path + # !!! } + # !!! workbook { + # !!! id + # !!! name + # !!! projectName + # !!! luid + # !!! owner { + # !!! username + # !!! } + # !!! } + # !!! datasourceFields { + # !!! __typename + # !!! id + # !!! name + # !!! description + # !!! datasource { + # !!! __typename + # !!! id + # !!! name + # !!! } + # !!! ... on ColumnField { + # !!! dataCategory + # !!! role + # !!! dataType + # !!! aggregation + # !!! } + # !!! ... on CalculatedField { + # !!! role + # !!! dataType + # !!! aggregation + # !!! formula + # !!! } + # !!! ... on GroupField { + # !!! role + # !!! dataType + # !!! } + # !!! ... on DatasourceField { + # !!! remoteField { + # !!! __typename + # !!! id + # !!! name + # !!! description + # !!! folderName + # !!! ... on ColumnField { + # !!! dataCategory + # !!! role + # !!! dataType + # !!! aggregation + # !!! } + # !!! ... on CalculatedField { + # !!! role + # !!! dataType + # !!! aggregation + # !!! formula + # !!! } + # !!! ... on GroupField { + # !!! role + # !!! dataType + # !!! } + # !!! } + # !!! } + # !!! } + # !!! } + # !!! pageInfo { + # !!! hasNextPage + # !!! endCursor + # !!! } + # !!! } + # !!! } + # !!! """ + # !!! ) + # !!! variables: Dict[str, object] = {"first": first, "after": after} + # !!! response = await self.execute( + # !!! query=query, + # !!! operation_name="GetItems_sheetsConnection", + # !!! variables=variables, + # !!! **kwargs, + # !!! ) + # !!! data = self.get_data(response) + # !!! return GetItemsSheetsConnection.model_validate(data) async def get_items_workbooks_connection( self, @@ -579,5 +584,11 @@ async def get_items_workbooks_connection( variables=variables, **kwargs, ) + logger.info( + f"Ariadne.client.get_items_workbooks_connection.response={response}" + ) + logger.info( + f"Ariadne.client.get_items_workbooks_connection.response={response.json()}" + ) data = self.get_data(response) return GetItemsWorkbooksConnection.model_validate(data) diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py index ac4fa5d865ee4..8f02936dd3a6a 100644 --- a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/get_items_workbooks_connection.py @@ -65,6 +65,6 @@ class GetItemsWorkbooksConnectionWorkbooksConnectionPageInfo(BaseModel): end_cursor: Optional[str] = Field(alias="endCursor") -GetItemsWorkbooksConnection.model_rebuild() -GetItemsWorkbooksConnectionWorkbooksConnection.model_rebuild() -GetItemsWorkbooksConnectionWorkbooksConnectionNodes.model_rebuild() +# !!! GetItemsWorkbooksConnection.model_rebuild() +# !!! GetItemsWorkbooksConnectionWorkbooksConnection.model_rebuild() +# !!! GetItemsWorkbooksConnectionWorkbooksConnectionNodes.model_rebuild() diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/schema.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/schema.py index 681f7d115f2c2..fd464afa8e085 100644 --- a/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/schema.py +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_turms/schema.py @@ -232,7 +232,7 @@ class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesColumnsRef "The database to which this table belongs" the_schema: Optional[str] = Field( default=None, alias="schema" - ) # !! schema is a reserved word + ) # !!! schema is a reserved word "Name of table schema.\n \nNote: For some databases, such as Amazon Athena and Exasol, the schema attribute may not return the correct schema name for the table. For more information, see https://help.tableau.com/current/api/metadata_api/en-us/docs/meta_api_model.html#schema_attribute." full_name: Optional[str] = Field(default=None, alias="fullName") "Fully qualified table name" @@ -406,7 +406,7 @@ class GetItems_customSQLTablesConnectionCustomsqltablesconnectionNodesTables(Bas "The database to which this table belongs" the_schema: Optional[str] = Field( default=None, alias="schema" - ) # !! schema is a reserved word + ) # !!! schema is a reserved word "Name of table schema.\n \nNote: For some databases, such as Amazon Athena and Exasol, the schema attribute may not return the correct schema name for the table. For more information, see https://help.tableau.com/current/api/metadata_api/en-us/docs/meta_api_model.html#schema_attribute." full_name: Optional[str] = Field(default=None, alias="fullName") "Fully qualified table name" @@ -634,7 +634,7 @@ class GetItems_publishedDatasourcesConnectionPublisheddatasourcesconnectionNodes "The database to which this table belongs" the_schema: Optional[str] = Field( default=None, alias="schema" - ) # !! schema is a reserved word + ) # !!! schema is a reserved word "Name of table schema.\n \nNote: For some databases, such as Amazon Athena and Exasol, the schema attribute may not return the correct schema name for the table. For more information, see https://help.tableau.com/current/api/metadata_api/en-us/docs/meta_api_model.html#schema_attribute." full_name: Optional[str] = Field(default=None, alias="fullName") "Fully qualified table name" @@ -1275,7 +1275,7 @@ class GetItems_embeddedDatasourcesConnectionEmbeddeddatasourcesconnectionNodesUp "The database to which this table belongs" the_schema: Optional[str] = Field( default=None, alias="schema" - ) # !! schema is a reserved keyword + ) # !!! schema is a reserved keyword "Name of table schema.\n \nNote: For some databases, such as Amazon Athena and Exasol, the schema attribute may not return the correct schema name for the table. For more information, see https://help.tableau.com/current/api/metadata_api/en-us/docs/meta_api_model.html#schema_attribute." full_name: Optional[str] = Field(default=None, alias="fullName") "Fully qualified table name" diff --git a/metadata-ingestion/src/datahub/ingestion/source/tableau/tableau.py b/metadata-ingestion/src/datahub/ingestion/source/tableau/tableau.py index 638af147ddb6f..78b857812f2ba 100644 --- a/metadata-ingestion/src/datahub/ingestion/source/tableau/tableau.py +++ b/metadata-ingestion/src/datahub/ingestion/source/tableau/tableau.py @@ -943,6 +943,10 @@ def get_workunits_internal(self) -> Iterable[MetadataWorkUnit]: if self.server is None or not self.server.is_signed_in(): return try: + ############################################## + ################## PoC ####################### + ############################################## + # TURMS # mypy errors @@ -966,11 +970,13 @@ def get_workunits_internal(self) -> Iterable[MetadataWorkUnit]: query=GetItems_workbooksConnection.Meta.document, variables=variables.json(), ) - logger.info(f"[[TURMS]] Tableau Workbooks: {result}") + logger.info(f"[[TURMS]] Result: {result}") + workbooks = GetItems_workbooksConnection(**result["data"]) + logger.info(f"[[TURMS]] Workbooks: {workbooks}") # After some manual edits to fix the 'schema' field issue and ignoring mypy errors - # -[2025-01-29 17:41:24,631] INFO {datahub.ingestion.source.tableau.tableau:962} - [[TURMS]] Query: query GetItems_workbooksConnection($first: Int, $after: String) { + # [2025-01-30 10:12:28,257] INFO {datahub.ingestion.source.tableau.tableau:962} - [[TURMS]] Query: query GetItems_workbooksConnection($first: Int, $after: String) { # workbooksConnection( # first: $first # after: $after @@ -1016,7 +1022,8 @@ def get_workunits_internal(self) -> Iterable[MetadataWorkUnit]: # __typename # } # } Variables: {"first": 100, "after": null} - # [2025-01-29 17:41:25,070] INFO {datahub.ingestion.source.tableau.tableau:967} - [[TURMS]] Tableau Workbooks: {'data': {'workbooksConnection': {'nodes': [{'id': '280d3fd0-c431-30c3-2e8f-c2620a4f472e', 'name': 'customer_profit_wb', 'luid': '3c6b22b8-5c42-413f-9505-f5d4715413db', 'uri': 'sites/71413/workbooks/2782740', 'projectName': 'project_test2', 'owner': {'username': 'harshal@acryl.io', '__typename': 'TableauUser'}, 'description': '', 'createdAt': '2024-09-03T04:36:19Z', 'updatedAt': '2024-09-03T04:36:19Z', 'tags': [], 'sheets': [{'id': 'aa141b11-a1ae-fef6-4a25-28b85d62b3f4', '__typename': 'Sheet'}], 'dashboards': [], 'embeddedDatasources': [{'id': 'a00e6ea7-64f5-f999-9967-236609717f86', '__typename': 'EmbeddedDatasource'}], '__typename': 'Workbook'}], 'pageInfo': {'hasNextPage': False, 'endCursor': None, '__typename': 'PageInfo'}, '__typename': 'WorkbooksConnection'}}} + # [2025-01-30 10:12:28,669] INFO {datahub.ingestion.source.tableau.tableau:969} - [[TURMS]] Result: {'data': {'workbooksConnection': {'nodes': [{'id': '280d3fd0-c431-30c3-2e8f-c2620a4f472e', 'name': 'customer_profit_wb', 'luid': '3c6b22b8-5c42-413f-9505-f5d4715413db', 'uri': 'sites/71413/workbooks/2782740', 'projectName': 'project_test2', 'owner': {'username': 'harshal@acryl.io', '__typename': 'TableauUser'}, 'description': '', 'createdAt': '2024-09-03T04:36:19Z', 'updatedAt': '2024-09-03T04:36:19Z', 'tags': [], 'sheets': [{'id': 'aa141b11-a1ae-fef6-4a25-28b85d62b3f4', '__typename': 'Sheet'}], 'dashboards': [], 'embeddedDatasources': [{'id': 'a00e6ea7-64f5-f999-9967-236609717f86', '__typename': 'EmbeddedDatasource'}], '__typename': 'Workbook'}], 'pageInfo': {'hasNextPage': False, 'endCursor': None, '__typename': 'PageInfo'}, '__typename': 'WorkbooksConnection'}}} + # [2025-01-30 10:12:28,669] INFO {datahub.ingestion.source.tableau.tableau:971} - [[TURMS]] Workbooks: workbooks_connection=GetItems_workbooksConnectionWorkbooksconnection(typename='WorkbooksConnection', nodes=[GetItems_workbooksConnectionWorkbooksconnectionNodes(typename='Workbook', id='280d3fd0-c431-30c3-2e8f-c2620a4f472e', name='customer_profit_wb', luid='3c6b22b8-5c42-413f-9505-f5d4715413db', uri='sites/71413/workbooks/2782740', project_name='project_test2', owner=GetItems_workbooksConnectionWorkbooksconnectionNodesOwner(typename='TableauUser', username='harshal@acryl.io'), description='', created_at=datetime.datetime(2024, 9, 3, 4, 36, 19, tzinfo=datetime.timezone.utc), updated_at=datetime.datetime(2024, 9, 3, 4, 36, 19, tzinfo=datetime.timezone.utc), tags=[], sheets=[GetItems_workbooksConnectionWorkbooksconnectionNodesSheets(typename='Sheet', id='aa141b11-a1ae-fef6-4a25-28b85d62b3f4')], dashboards=[], embedded_datasources=[GetItems_workbooksConnectionWorkbooksconnectionNodesEmbeddeddatasources(typename='EmbeddedDatasource', id='a00e6ea7-64f5-f999-9967-236609717f86')])], page_info=GetItems_workbooksConnectionWorkbooksconnectionPageinfo(typename='PageInfo', has_next_page=False, end_cursor=None)) # SGQLC @@ -1068,8 +1075,10 @@ def get_workunits_internal(self) -> Iterable[MetadataWorkUnit]: query=str(op), variables=dict(first=100, after=None) ) logger.info(f"[[SGQLC]] Result: {result}") + workbooks = op + result + logger.info(f"[[SGQLC]] Workbooks: {workbooks}") - # [2025-01-29 17:41:25,119] INFO {datahub.ingestion.source.tableau.tableau:1015} - [[SGQLC]] Query: query GetItems_workbooksConnection($first: Int, $after: String) { + # [2025-01-30 10:15:51,755] INFO {datahub.ingestion.source.tableau.tableau:1067} - [[SGQLC]] Query: query GetItems_workbooksConnection($first: Int, $after: String) { # workbooksConnection(first: $first, after: $after, filter: {projectNameWithin: ["project_test2"]}) { # nodes { # id @@ -1102,7 +1111,8 @@ def get_workunits_internal(self) -> Iterable[MetadataWorkUnit]: # } # } # } Variables: {'first': 100, 'after': None} - # [2025-01-29 17:41:25,568] INFO {datahub.ingestion.source.tableau.tableau:1020} - [[SGQLC]] Result: {'data': {'workbooksConnection': {'nodes': [{'id': '280d3fd0-c431-30c3-2e8f-c2620a4f472e', 'name': 'customer_profit_wb', 'luid': '3c6b22b8-5c42-413f-9505-f5d4715413db', 'uri': 'sites/71413/workbooks/2782740', 'projectName': 'project_test2', 'owner': {'username': 'harshal@acryl.io'}, 'description': '', 'createdAt': '2024-09-03T04:36:19Z', 'updatedAt': '2024-09-03T04:36:19Z', 'tags': [], 'sheets': [{'id': 'aa141b11-a1ae-fef6-4a25-28b85d62b3f4'}], 'dashboards': [], 'embeddedDatasources': [{'id': 'a00e6ea7-64f5-f999-9967-236609717f86'}]}], 'pageInfo': {'hasNextPage': False, 'endCursor': None}}}} + # [2025-01-30 10:15:52,186] INFO {datahub.ingestion.source.tableau.tableau:1073} - [[SGQLC]] Result: {'data': {'workbooksConnection': {'nodes': [{'id': '280d3fd0-c431-30c3-2e8f-c2620a4f472e', 'name': 'customer_profit_wb', 'luid': '3c6b22b8-5c42-413f-9505-f5d4715413db', 'uri': 'sites/71413/workbooks/2782740', 'projectName': 'project_test2', 'owner': {'username': 'harshal@acryl.io'}, 'description': '', 'createdAt': '2024-09-03T04:36:19Z', 'updatedAt': '2024-09-03T04:36:19Z', 'tags': [], 'sheets': [{'id': 'aa141b11-a1ae-fef6-4a25-28b85d62b3f4'}], 'dashboards': [], 'embeddedDatasources': [{'id': 'a00e6ea7-64f5-f999-9967-236609717f86'}]}], 'pageInfo': {'hasNextPage': False, 'endCursor': None}}}} + # [2025-01-30 10:15:52,188] INFO {datahub.ingestion.source.tableau.tableau:1075} - [[SGQLC]] Workbooks: Query(workbooks_connection=WorkbooksConnection(nodes=[Workbook(id='280d3fd0-c431-30c3-2e8f-c2620a4f472e', name='customer_profit_wb', luid='3c6b22b8-5c42-413f-9505-f5d4715413db', uri='sites/71413/workbooks/2782740', project_name='project_test2', owner=TableauUser(username='harshal@acryl.io'), description='', created_at=datetime.datetime(2024, 9, 3, 4, 36, 19, tzinfo=datetime.timezone.utc), updated_at=datetime.datetime(2024, 9, 3, 4, 36, 19, tzinfo=datetime.timezone.utc), tags=[], sheets=[Sheet(id='aa141b11-a1ae-fef6-4a25-28b85d62b3f4')], dashboards=[], embedded_datasources=[EmbeddedDatasource(id='a00e6ea7-64f5-f999-9967-236609717f86')])], page_info=PageInfo(has_next_page=False, end_cursor=None))) # ARIADNE @@ -1164,15 +1174,62 @@ def get_workunits_internal(self) -> Iterable[MetadataWorkUnit]: # src/datahub/ingestion/source/tableau/codegen_ariadne/client.py:525: error: "type[GetItemsSheetsConnection]" has no attribute "model_validate" [attr-defined] # src/datahub/ingestion/source/tableau/codegen_ariadne/client.py:583: error: "type[GetItemsWorkbooksConnection]" has no attribute "model_validate" [attr-defined] - from datahub.ingestion.source.tableau.codegen_ariadne.get_items_workbooks_connection import ( - GetItemsWorkbooksConnection as GetItemsWorkbooksConnectionAriadne, - ) - - op = GetItemsWorkbooksConnectionAriadne() - - logger.info( - f"[[ARIADNE]] Query: {op} Variables: {dict(first=100, after=None)}" - ) + import asyncio + + from datahub.ingestion.source.tableau.codegen_ariadne.client import Client + + # big concern, we cannot use the tableauserverclient library when using ariadne!! + + client = Client( + f"{self.server.server_address}/api/metadata/graphql", + {"X-tableau-auth": f"{self.server._auth_token}"}, + ) + workbooks = asyncio.run( + client.get_items_workbooks_connection(first=100, after=None) + ) + + logger.info(f"[[ARIADNE]] Worbooks: {workbooks}") + + # request/response ok, but fails the deserialization + + # [2025-01-30 13:24:20,595] INFO {datahub.ingestion.source.tableau.codegen_ariadne.client:586} - Ariadne.client.get_items_workbooks_connection.response= + # [2025-01-30 13:24:20,595] INFO {datahub.ingestion.source.tableau.codegen_ariadne.client:587} - Ariadne.client.get_items_workbooks_connection.response={'data': {'workbooksConnection': {'nodes': [{'id': '280d3fd0-c431-30c3-2e8f-c2620a4f472e', 'name': 'customer_profit_wb', 'luid': '3c6b22b8-5c42-413f-9505-f5d4715413db', 'uri': 'sites/71413/workbooks/2782740', 'projectName': 'project_test2', 'owner': {'username': 'harshal@acryl.io'}, 'description': '', 'createdAt': '2024-09-03T04:36:19Z', 'updatedAt': '2024-09-03T04:36:19Z', 'tags': [], 'sheets': [{'id': 'aa141b11-a1ae-fef6-4a25-28b85d62b3f4'}], 'dashboards': [], 'embeddedDatasources': [{'id': 'a00e6ea7-64f5-f999-9967-236609717f86'}]}], 'pageInfo': {'hasNextPage': False, 'endCursor': None}}}} + # [2025-01-30 13:24:20,597] ERROR {datahub.ingestion.run.pipeline:741} - Ingestion pipeline threw an uncaught exception: type object 'GetItemsWorkbooksConnection' has no attribute 'model_validate' + # Traceback (most recent call last): + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/run/pipeline.py", line 466, in run + # for wu in itertools.islice( + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/source/state/stale_entity_removal_handler.py", line 72, in auto_stale_entity_removal + # for wu in stream: + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/api/auto_work_units/auto_ensure_aspect_size.py", line 91, in ensure_aspect_size + # for wu in stream: + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/api/auto_work_units/auto_dataset_properties_aspect.py", line 62, in auto_patch_last_modified + # for wu in stream: + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/api/source_helpers.py", line 148, in auto_workunit_reporter + # for wu in stream: + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/api/source_helpers.py", line 252, in auto_browse_path_v2 + # for urn, batch in _batch_workunits_by_urn(stream): + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/api/source_helpers.py", line 508, in _batch_workunits_by_urn + # for wu in stream: + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/api/source_helpers.py", line 415, in auto_fix_empty_field_paths + # for wu in stream: + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/api/source_helpers.py", line 367, in auto_fix_duplicate_schema_field_paths + # for wu in stream: + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/api/source_helpers.py", line 171, in auto_materialize_referenced_tags_terms + # for wu in stream: + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/api/source_helpers.py", line 103, in auto_status_aspect + # for wu in stream: + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/source/tableau/tableau.py", line 1195, in get_workunits_internal + # workbooks = asyncio.run(client.get_items_workbooks_connection(first=100, after=None)) + # File "/Users/sergio/.pyenv/versions/3.10.15/lib/python3.10/asyncio/runners.py", line 44, in run + # return loop.run_until_complete(main) + # File "/Users/sergio/.pyenv/versions/3.10.15/lib/python3.10/asyncio/base_events.py", line 649, in run_until_complete + # return future.result() + # File "/Users/sergio/workspace/github/datahub-project/datahub/metadata-ingestion/src/datahub/ingestion/source/tableau/codegen_ariadne/client.py", line 589, in get_items_workbooks_connection + # return GetItemsWorkbooksConnection.model_validate(data) + # AttributeError: type object 'GetItemsWorkbooksConnection' has no attribute 'model_validate' + # [2025-01-30 13:24:20,604] INFO {datahub.cli.ingest_cli:144} - Finished metadata ingestion + + ############################################## if self.config.ingest_multiple_sites: for site in list(TSC.Pager(self.server.sites)):